heapoffset.cpp revision 29e82f9045a3d4eb6c3547e48725b671fadaf2ca
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * IPRT - An Offset Based Heap.
3f1e0eea71cabeb90529e546f16eb7aee513fde9vboxsync * Copyright (C) 2006-2009 Sun Microsystems, Inc.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * available from http://www.virtualbox.org. This file is free software;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * you can redistribute it and/or modify it under the terms of the GNU
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * General Public License (GPL) as published by the Free Software
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
a16eb14ad7a4b5ef91ddc22d3e8e92d930f736fcvboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The contents of this file may alternatively be used under the terms
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * of the Common Development and Distribution License Version 1.0
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * VirtualBox OSE distribution, in which case the provisions of the
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * CDDL are applicable instead of those of the GPL.
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync * You may elect to license modified versions of this file under the
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync * terms and conditions of either the GPL or the CDDL or both.
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync * additional information or have any questions.
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync/*******************************************************************************
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync* Header Files *
43747b1f0bc8302a238fb35e55857a5e9aa1933dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Structures and Typedefs *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Pointer to the heap anchor block. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsynctypedef struct RTHEAPOFFSETINTERNAL *PRTHEAPOFFSETINTERNAL;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Pointer to a heap block. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsynctypedef struct RTHEAPOFFSETBLOCK *PRTHEAPOFFSETBLOCK;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Pointer to a free heap block. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Structure describing a block in an offset based heap.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If this block is allocated, it is followed by the user data.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If this block is free, see RTHEAPOFFSETFREE.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** The next block in the global block list. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** The previous block in the global block list. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** Offset into the heap of this block. Used to locate the anchor block. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** Flags + magic. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** The block is free if this flag is set. When cleared it's allocated. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync/** The magic value. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync#define RTHEAPOFFSETBLOCK_FLAGS_MAGIC (UINT32_C(0xabcdef00))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** The mask that needs to be applied to RTHEAPOFFSETBLOCK::fFlags to obtain the magic value. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync#define RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK (~RT_BIT_32(0))
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * Checks if the specified block is valid or not.
3242fe628b2306c050fb28c489d50bc63118f0c5vboxsync * @returns boolean answer.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @param pBlock Pointer to a RTHEAPOFFSETBLOCK structure.
3242fe628b2306c050fb28c489d50bc63118f0c5vboxsync ( ((pBlock)->fFlags & RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK) == RTHEAPOFFSETBLOCK_FLAGS_MAGIC )
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Checks if the specified block is valid and in use.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @returns boolean answer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pBlock Pointer to a RTHEAPOFFSETBLOCK structure.
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync ( ((pBlock)->fFlags & (RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK | RTHEAPOFFSETBLOCK_FLAGS_FREE)) \
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * Checks if the specified block is valid and free.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @returns boolean answer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pBlock Pointer to a RTHEAPOFFSETBLOCK structure.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync ( ((pBlock)->fFlags & (RTHEAPOFFSETBLOCK_FLAGS_MAGIC_MASK | RTHEAPOFFSETBLOCK_FLAGS_FREE)) \
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync == (RTHEAPOFFSETBLOCK_FLAGS_MAGIC | RTHEAPOFFSETBLOCK_FLAGS_FREE) )
1db6afc370c2fa84144478dffa9c1ed3c28c7158vboxsync * Checks if the specified block is free or not.
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync * @returns boolean answer.
1db6afc370c2fa84144478dffa9c1ed3c28c7158vboxsync * @param pBlock Pointer to a valid RTHEAPOFFSETBLOCK structure.
1db6afc370c2fa84144478dffa9c1ed3c28c7158vboxsync#define RTHEAPOFFSETBLOCK_IS_FREE(pBlock) (!!((pBlock)->fFlags & RTHEAPOFFSETBLOCK_FLAGS_FREE))
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync * A free heap block.
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync * This is an extended version of RTHEAPOFFSETBLOCK that takes the unused
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync * user data to store free list pointers and a cached size value.
1db6afc370c2fa84144478dffa9c1ed3c28c7158vboxsync /** Core stuff. */
1db6afc370c2fa84144478dffa9c1ed3c28c7158vboxsync /** Pointer to the next free block. */
1db6afc370c2fa84144478dffa9c1ed3c28c7158vboxsync /** Pointer to the previous free block. */
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync /** The size of the block (excluding the RTHEAPOFFSETBLOCK part). */
05406988cc320ac1b0971de976b6cf0c986044a9vboxsync /** An alignment filler to make it a multiple of 16 bytes. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * The heap anchor block.
3242fe628b2306c050fb28c489d50bc63118f0c5vboxsync * This structure is placed at the head of the memory block specified to RTHeapOffsetInit(),
3242fe628b2306c050fb28c489d50bc63118f0c5vboxsync * which means that the first RTHEAPOFFSETBLOCK appears immediately after this structure.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync /** The typical magic (RTHEAPOFFSET_MAGIC). */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** The heap size. (This structure is included!) */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync /** The amount of free memory in the heap. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** Free head pointer. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /** Free tail pointer. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync /** Make the size of this structure 32 bytes. */
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync/** The minimum allocation size. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define RTHEAPOFFSET_MIN_BLOCK (sizeof(RTHEAPOFFSETBLOCK))
23de3d76e5d27015e334e6ff763ab08de5969363vboxsyncAssertCompile(RTHEAPOFFSET_MIN_BLOCK >= sizeof(RTHEAPOFFSETBLOCK));
323b78bf4831666c95416edf3b6e54657a769e5dvboxsyncAssertCompile(RTHEAPOFFSET_MIN_BLOCK >= sizeof(RTHEAPOFFSETFREE) - sizeof(RTHEAPOFFSETBLOCK));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** The minimum and default alignment. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define RTHEAPOFFSET_ALIGNMENT (sizeof(RTHEAPOFFSETBLOCK))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Defined Constants And Macros *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Converts RTHEAPOFFSETBLOCK::offSelf into a heap anchor block pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns Pointer of given type.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pBlock The block to find the heap anchor block for.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define RTHEAPOFF_GET_ANCHOR(pBlock) ( (PRTHEAPOFFSETINTERNAL)((uint8_t *)(pBlock) - (pBlock)->offSelf ) )
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Converts an offset to a pointer.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * All offsets are relative to the heap to make life simple.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns Pointer of given type.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * @param pHeapInt Pointer to the heap anchor block.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param off The offset to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param type The desired type.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync# define RTHEAPOFF_TO_PTR(pHeapInt, off, type) ( (type)rtHeapOffCheckedOffToPtr(pHeapInt, off) )
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync# define RTHEAPOFF_TO_PTR(pHeapInt, off, type) ( (type)((off) ? (uint8_t *)(pHeapInt) + (off) : NULL) )
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Converts a pointer to an offset.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * All offsets are relative to the heap to make life simple.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns Offset into the heap.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pHeapInt Pointer to the heap anchor block.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param ptr The pointer to convert.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync# define RTHEAPOFF_TO_OFF(pHeapInt, ptr) rtHeapOffCheckedPtrToOff(pHeapInt, ptr)
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync# define RTHEAPOFF_TO_OFF(pHeapInt, ptr) ( (uint32_t)((ptr) ? (uintptr_t)(ptr) - (uintptr_t)(pHeapInt) : UINT32_C(0)) )
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define ASSERT_L(a, b) AssertMsg((a) < (b), ("a=%08x b=%08x\n", (a), (b)))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define ASSERT_LE(a, b) AssertMsg((a) <= (b), ("a=%08x b=%08x\n", (a), (b)))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#define ASSERT_G(a, b) AssertMsg((a) > (b), ("a=%08x b=%08x\n", (a), (b)))
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync#define ASSERT_GE(a, b) AssertMsg((a) >= (b), ("a=%08x b=%08x\n", (a), (b)))
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync#define ASSERT_ALIGN(a) AssertMsg(!((uintptr_t)(a) & (RTHEAPOFFSET_ALIGNMENT - 1)), ("a=%p\n", (uintptr_t)(a)))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_L((pBlock)->offPrev, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
61e80138f3c5ea5213990bde94a973c8e64d1dadvboxsync ASSERT_GE((pBlock)->offPrev, sizeof(RTHEAPOFFSETINTERNAL)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert((pBlock) == (PRTHEAPOFFSETBLOCK)((pHeapInt) + 1)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } while (0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_G((pBlock)->offNext, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } while (0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync do { AssertMsg(RTHEAPOFFSETBLOCK_IS_VALID(pBlock), ("%#x\n", (pBlock)->fFlags)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(RTHEAPOFF_GET_ANCHOR(pBlock) == (pHeapInt), ("%p != %p\n", RTHEAPOFF_GET_ANCHOR(pBlock), (pHeapInt))); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_GE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), sizeof(RTHEAPOFFSETINTERNAL)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_L( RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->cbHeap); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } while (0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync do { AssertMsg(RTHEAPOFFSETBLOCK_IS_VALID_USED((pBlock)), ("%#x\n", (pBlock)->fFlags)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(RTHEAPOFF_GET_ANCHOR(pBlock) == (pHeapInt), ("%p != %p\n", RTHEAPOFF_GET_ANCHOR(pBlock), (pHeapInt))); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_GE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), sizeof(RTHEAPOFFSETINTERNAL)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_L( RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->cbHeap); \
be9bc9b4ba510c4b4159c193f783d024633ef8e9vboxsync } while (0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_GE((pBlock)->offPrev, (pHeapInt)->offFreeHead); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_L((pBlock)->offPrev, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_LE((pBlock)->offPrev, (pBlock)->Core.offPrev); \
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync Assert((pBlock) == RTHEAPOFF_TO_PTR(pHeapInt, (pHeapInt)->offFreeHead, PRTHEAPOFFSETFREE) ); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } while (0)
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync ASSERT_LE((pBlock)->offNext, (pHeapInt)->offFreeTail); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_G((pBlock)->offNext, RTHEAPOFF_TO_OFF(pHeapInt, pBlock)); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_GE((pBlock)->offNext, (pBlock)->Core.offNext); \
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync Assert((pBlock) == RTHEAPOFF_TO_PTR(pHeapInt, (pHeapInt)->offFreeTail, PRTHEAPOFFSETFREE)); \
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync } while (0)
090f6abdd6282f48527b83162b8b441425f05e36vboxsync do { size_t cbCalc = ((pBlock)->Core.offNext ? (pBlock)->Core.offNext : (pHeapInt)->cbHeap) \
090f6abdd6282f48527b83162b8b441425f05e36vboxsync - RTHEAPOFF_TO_OFF((pHeapInt), (pBlock)) - sizeof(RTHEAPOFFSETBLOCK); \
118e1c3f853f78b4aec64afdcb8379981f41314fvboxsync AssertMsg((pBlock)->cb == cbCalc, ("cb=%#zx cbCalc=%#zx\n", (pBlock)->cb, cbCalc)); \
118e1c3f853f78b4aec64afdcb8379981f41314fvboxsync } while (0)
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync# define ASSERT_FREE_CB(pHeapInt, pBlock) do {} while (0)
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync/** Asserts that a free block is valid. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(RTHEAPOFFSETBLOCK_IS_VALID_FREE(&(pBlock)->Core)); \
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync ASSERT_GE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->offFreeHead); \
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync ASSERT_LE(RTHEAPOFF_TO_OFF(pHeapInt, pBlock), (pHeapInt)->offFreeTail); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } while (0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Asserts that the heap anchor block is ok. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert((pHeapInt)->u32Magic == RTHEAPOFFSET_MAGIC); \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync } while (0)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/*******************************************************************************
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync* Internal Functions *
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync*******************************************************************************/
323b78bf4831666c95416edf3b6e54657a769e5dvboxsyncstatic void rtHeapOffsetAssertAll(PRTHEAPOFFSETINTERNAL pHeapInt);
3f1e0eea71cabeb90529e546f16eb7aee513fde9vboxsyncstatic PRTHEAPOFFSETBLOCK rtHeapOffsetAllocBlock(PRTHEAPOFFSETINTERNAL pHeapInt, size_t cb, size_t uAlignment);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic void rtHeapOffsetFreeBlock(PRTHEAPOFFSETINTERNAL pHeapInt, PRTHEAPOFFSETBLOCK pBlock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Checked version of RTHEAPOFF_TO_PTR. */
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsyncDECLINLINE(void *) rtHeapOffCheckedOffToPtr(PRTHEAPOFFSETINTERNAL pHeapInt, uint32_t off)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(off < pHeapInt->cbHeap, ("%#x %#x\n", off, pHeapInt->cbHeap));
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync AssertMsg(off >= sizeof(*pHeapInt), ("%#x %#x\n", off, sizeof(*pHeapInt)));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync/** Checked version of RTHEAPOFF_TO_OFF. */
7e960d3a0a8a3a84d7aba2cca45d72b1c31cc97bvboxsyncDECLINLINE(uint32_t) rtHeapOffCheckedPtrToOff(PRTHEAPOFFSETINTERNAL pHeapInt, void *pv)
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync uintptr_t off = (uintptr_t)pv - (uintptr_t)pHeapInt;
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync AssertMsg(off < pHeapInt->cbHeap, ("%#x %#x\n", off, pHeapInt->cbHeap));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(off >= sizeof(*pHeapInt), ("%#x %#x\n", off, sizeof(*pHeapInt)));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync#endif /* RTHEAPOFFSET_STRICT */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncRTDECL(int) RTHeapOffsetInit(PRTHEAPOFFSET phHeap, void *pvMemory, size_t cbMemory)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync unsigned i;
332ccb6ac6feb4b50ec24d63ff029119164182ffvboxsync * Validate input. The imposed minimum heap size is just a convenient value.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(cbMemory >= PAGE_SIZE, VERR_INVALID_PARAMETER);
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync AssertReturn((uintptr_t)pvMemory + (cbMemory - 1) > (uintptr_t)cbMemory, VERR_INVALID_PARAMETER);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Place the heap anchor block at the start of the heap memory,
ad27e1d5e48ca41245120c331cc88b50464813cevboxsync * enforce 32 byte alignment of it. Also align the heap size correctly.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync const uintptr_t off = 32 - ((uintptr_t)pvMemory & 31);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pHeapInt = (PRTHEAPOFFSETINTERNAL)((uintptr_t)pvMemory + off);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Init the heap anchor block. */
13d75a5db336ccb682d7ab28b397a4f0b8982ea3vboxsync pHeapInt->offFreeTail = pHeapInt->offFreeHead = sizeof(*pHeapInt);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync for (i = 0; i < RT_ELEMENTS(pHeapInt->au32Alignment); i++)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* Init the single free block. */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree = RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->Core.fFlags = RTHEAPOFFSETBLOCK_FLAGS_MAGIC | RTHEAPOFFSETBLOCK_FLAGS_FREE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncRTDECL(void *) RTHeapOffsetAlloc(RTHEAPOFFSET hHeap, size_t cb, size_t cbAlignment)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Validate and adjust the input.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert((cbAlignment & ~(cbAlignment - 1)) == cbAlignment);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Do the allocation.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pBlock = rtHeapOffsetAllocBlock(pHeapInt, cb, cbAlignment);
a64bf60e92e5cb8a76aa6c8e92193932d88a906fvboxsyncRTDECL(void *) RTHeapOffsetAllocZ(RTHEAPOFFSET hHeap, size_t cb, size_t cbAlignment)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Validate and adjust the input.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync Assert((cbAlignment & ~(cbAlignment - 1)) == cbAlignment);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Do the allocation.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync pBlock = rtHeapOffsetAllocBlock(pHeapInt, cb, cbAlignment);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Allocates a block of memory from the specified heap.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * No parameter validation or adjustment is performed.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns Pointer to the allocated block.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @returns NULL on failure.
d45f7f7fe0c28b500b45b2dc88d7a04f4c0be6b8vboxsync * @param pHeapInt The heap.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param cb Size of the memory block to allocate.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param uAlignment The alignment specifications for the allocated block.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic PRTHEAPOFFSETBLOCK rtHeapOffsetAllocBlock(PRTHEAPOFFSETINTERNAL pHeapInt, size_t cb, size_t uAlignment)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn((pHeapInt)->u32Magic == RTHEAPOFFSET_MAGIC, NULL);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Search for a fitting block from the lower end of the heap.
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync for (pFree = RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree = RTHEAPOFF_TO_PTR(pHeapInt, pFree->offNext, PRTHEAPOFFSETFREE))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Match for size and alignment.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync offAlign = (uintptr_t)(&pFree->Core + 1) & (uAlignment - 1);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Make a stack copy of the free block header and adjust the pointer.
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync pFree = (PRTHEAPOFFSETFREE)((uintptr_t)pFree + offAlign);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * Donate offAlign bytes to the node in front of us.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * If we're the head node, we'll have to create a fake node. We'll
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * mark it USED for simplicity.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * (Should this policy of donating memory to the guy in front of us
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * cause big 'leaks', we could create a new free node if there is room
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * for that.)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPrev = RTHEAPOFF_TO_PTR(pHeapInt, Free.Core.offPrev, PRTHEAPOFFSETBLOCK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertMsg(!RTHEAPOFFSETBLOCK_IS_FREE(pPrev), ("Impossible!\n"));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPrev->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync pPrev->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pPrev->offSelf = RTHEAPOFF_TO_OFF(pHeapInt, pPrev);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Recreate pFree in the new position and adjust the neighbors.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->Core.offSelf = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync /* the core */
7e960d3a0a8a3a84d7aba2cca45d72b1c31cc97bvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = pFree->Core.offSelf;
42c1972c22e09797b4b24afbd0ec114ed076c37cvboxsync pFree->Core.offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pPrev);
0ebb1ef53864eb9cc97580f722288c9b29bc5d03vboxsync /* the free part */
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->offNext, PRTHEAPOFFSETFREE)->offPrev = pFree->Core.offSelf;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->offPrev, PRTHEAPOFFSETFREE)->offNext = pFree->Core.offSelf;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Split off a new FREE block?
332ccb6ac6feb4b50ec24d63ff029119164182ffvboxsync if (pFree->cb >= cb + RT_ALIGN_Z(sizeof(RTHEAPOFFSETFREE), RTHEAPOFFSET_ALIGNMENT))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Move the FREE block up to make room for the new USED block.
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync PRTHEAPOFFSETFREE pNew = (PRTHEAPOFFSETFREE)((uintptr_t)&pFree->Core + cb + sizeof(RTHEAPOFFSETBLOCK));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pNew->Core.offSelf = RTHEAPOFF_TO_OFF(pHeapInt, pNew);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = pNew->Core.offSelf;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pNew->Core.offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync pNew->Core.fFlags = RTHEAPOFFSETBLOCK_FLAGS_MAGIC | RTHEAPOFFSETBLOCK_FLAGS_FREE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pNew->offNext, PRTHEAPOFFSETFREE)->offPrev = pNew->Core.offSelf;
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pNew->offPrev, PRTHEAPOFFSETFREE)->offNext = pNew->Core.offSelf;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pNew->cb = (pNew->Core.offNext ? pNew->Core.offNext : pHeapInt->cbHeap) \
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Update the old FREE node making it a USED node.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->Core.fFlags &= ~RTHEAPOFFSETBLOCK_FLAGS_FREE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Link it out of the free list.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->offNext, PRTHEAPOFFSETFREE)->offPrev = pFree->offPrev;
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->offPrev, PRTHEAPOFFSETFREE)->offNext = pFree->offNext;
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync * Convert it to a used block.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->Core.fFlags &= ~RTHEAPOFFSETBLOCK_FLAGS_FREE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncRTDECL(void) RTHeapOffsetFree(RTHEAPOFFSET hHeap, void *pv)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Validate input.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(RT_ALIGN_P(pv, RTHEAPOFFSET_ALIGNMENT) == pv);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get the block and heap. If in strict mode, validate these.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(pHeapInt == (PRTHEAPOFFSETINTERNAL)hHeap || !hHeap);
323b78bf4831666c95416edf3b6e54657a769e5dvboxsync * Poison the block.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync const size_t cbBlock = (pBlock->pNext ? (uintptr_t)pBlock->pNext : (uintptr_t)pHeapInt->pvEnd)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync memset(pBlock + 1, RTHEAPOFFSET_FREE_POISON, cbBlock);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Call worker which does the actual job.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Free a memory block.
1df4b0cdc5ec23d817014f9347ef28222b51e3fbvboxsync * @param pHeapInt The heap.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * @param pBlock The memory block to free.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncstatic void rtHeapOffsetFreeBlock(PRTHEAPOFFSETINTERNAL pHeapInt, PRTHEAPOFFSETBLOCK pBlock)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync PRTHEAPOFFSETFREE pFree = (PRTHEAPOFFSETFREE)pBlock;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Look for the closest free list blocks by walking the blocks right
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * of us (both lists are sorted by address).
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRight = RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETFREE);
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync while (pRight && !RTHEAPOFFSETBLOCK_IS_FREE(&pRight->Core))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRight = RTHEAPOFF_TO_PTR(pHeapInt, pRight->Core.offNext, PRTHEAPOFFSETFREE);
dd8efff5286a99cf8d9b3a5e8dd62340973f3cc1vboxsync pLeft = RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeTail, PRTHEAPOFFSETFREE);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pLeft = RTHEAPOFF_TO_PTR(pHeapInt, pRight->offPrev, PRTHEAPOFFSETFREE);
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync AssertMsgReturnVoid(pLeft != pFree, ("Freed twice! pv=%p (pBlock=%p)\n", pBlock + 1, pBlock));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync ASSERT_L(RTHEAPOFF_TO_OFF(pHeapInt, pLeft), RTHEAPOFF_TO_OFF(pHeapInt, pFree));
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync Assert(!pRight || (uintptr_t)pRight > (uintptr_t)pFree);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(!pLeft || RTHEAPOFF_TO_PTR(pHeapInt, pLeft->offNext, PRTHEAPOFFSETFREE) == pRight);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Insert at the head of the free block list?
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(pRight == RTHEAPOFF_TO_PTR(pHeapInt, pHeapInt->offFreeHead, PRTHEAPOFFSETFREE));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->Core.fFlags |= RTHEAPOFFSETBLOCK_FLAGS_FREE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pRight);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pRight->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsync pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsync pHeapInt->offFreeHead = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Can we merge with left hand free block?
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsync if (pLeft->Core.offNext == RTHEAPOFF_TO_OFF(pHeapInt, pFree))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync RTHEAPOFF_TO_PTR(pHeapInt, pFree->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pLeft);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * No, just link it into the free list then.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->Core.fFlags |= RTHEAPOFFSETBLOCK_FLAGS_FREE;
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pRight);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pLeft);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pLeft->offNext = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
e11fe099decbb0f65cfcc7e2939fa00bacefbb1cvboxsync pRight->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
ab0130d1627b2b214952b929de71b89e4ba41eb1vboxsync * Can we merge with right hand free block?
9f16100a870e25701da9bc9819e15c0f9fb3870evboxsync && pRight->Core.offPrev == RTHEAPOFF_TO_OFF(pHeapInt, pFree))
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync RTHEAPOFF_TO_PTR(pHeapInt, pRight->Core.offNext, PRTHEAPOFFSETBLOCK)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync RTHEAPOFF_TO_PTR(pHeapInt, pRight->offNext, PRTHEAPOFFSETFREE)->offPrev = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync pHeapInt->offFreeTail = RTHEAPOFF_TO_OFF(pHeapInt, pFree);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync * Calculate the size and update free stats.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pFree->cb = (pFree->Core.offNext ? pFree->Core.offNext : pHeapInt->cbHeap)
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsync - RTHEAPOFF_TO_OFF(pHeapInt, pFree) - sizeof(RTHEAPOFFSETBLOCK);
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsync * Internal consistency check (relying on assertions).
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsync * @param pHeapInt
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsyncstatic void rtHeapOffsetAssertAll(PRTHEAPOFFSETINTERNAL pHeapInt)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pBlock = RTHEAPOFF_TO_PTR(pHeapInt, pBlock->Core.offNext, PRTHEAPOFFSETFREE))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(pBlock->offPrev == RTHEAPOFF_TO_OFF(pHeapInt, pPrevFree));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(pPrevFree || pHeapInt->offFreeHead == RTHEAPOFF_TO_OFF(pHeapInt, pBlock));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(!pPrev || RTHEAPOFF_TO_OFF(pHeapInt, pPrev) == pBlock->Core.offPrev);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync Assert(pHeapInt->offFreeTail == RTHEAPOFF_TO_OFF(pHeapInt, pPrevFree));
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncRTDECL(size_t) RTHeapOffsetSize(RTHEAPOFFSET hHeap, void *pv)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Validate input.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync AssertReturn(RT_ALIGN_P(pv, RTHEAPOFFSET_ALIGNMENT) == pv, 0);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Get the block and heap. If in strict mode, validate these.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync Assert(pHeapInt == (PRTHEAPOFFSETINTERNAL)hHeap || !hHeap);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync * Calculate the block size.
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync cbBlock = (pBlock->offNext ? pBlock->offNext : pHeapInt->cbHeap)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync - RTHEAPOFF_TO_OFF(pHeapInt, pBlock) - sizeof(RTHEAPOFFSETBLOCK);
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsyncRTDECL(size_t) RTHeapOffsetGetHeapSize(RTHEAPOFFSET hHeap)
8dee1778d3770cdc584752c84acf4899d8bfc9f9vboxsyncRTDECL(size_t) RTHeapOffsetGetFreeSize(RTHEAPOFFSET hHeap)
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsyncRTDECL(void) RTHeapOffsetDump(RTHEAPOFFSET hHeap, PFNRTHEAPOFFSETPRINTF pfnPrintf)
0f8b9243304469cd1e58d6986931bbfed5ba359evboxsync PRTHEAPOFFSETINTERNAL pHeapInt = (PRTHEAPOFFSETINTERNAL)hHeap;
be9bc9b4ba510c4b4159c193f783d024633ef8e9vboxsync pfnPrintf("**** Dumping Heap %p - cbHeap=%x cbFree=%x ****\n",
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync pBlock = RTHEAPOFF_TO_PTR(pHeapInt, pBlock->Core.offNext, PRTHEAPOFFSETFREE))
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync size_t cb = (pBlock->offNext ? pBlock->Core.offNext : pHeapInt->cbHeap)
d408b82da0773c7e8cd4b3a01cb8a065a2c73a2dvboxsync - RTHEAPOFF_TO_OFF(pHeapInt, pBlock) - sizeof(RTHEAPOFFSETBLOCK);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync pfnPrintf("%p %06x FREE offNext=%06x offPrev=%06x fFlags=%#x cb=%#06x : cb=%#06x offNext=%06x offPrev=%06x\n",
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync pBlock, pBlock->Core.offSelf, pBlock->Core.offNext, pBlock->Core.offPrev, pBlock->Core.fFlags, cb,
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync pfnPrintf("%p %06x USED offNext=%06x offPrev=%06x fFlags=%#x cb=%#06x\n",
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync pBlock, pBlock->Core.offSelf, pBlock->Core.offNext, pBlock->Core.offPrev, pBlock->Core.fFlags, cb);
ebf9e36b6e5548e4db69cebbef120e669a459afevboxsync pfnPrintf("**** Done dumping Heap %p ****\n", hHeap);