path: root/vpx_mem/memory_manager/hmm_base.c

/*
 *  Copyright (c) 2010 The WebM project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */


/* This code is in the public domain.
** Version: 1.1  Author: Walt Karas
*/

#include "hmm_intrnl.h"

void U(init)(U(descriptor) *desc)
{
    desc->avl_tree_root = 0;
    desc->last_freed = 0;
}

/* Remove a free block from a bin's doubly-linked list when it is not,
** the first block in the bin.
*/
void U(dll_remove)(
    /* Pointer to pointer record in the block to be removed. */
    ptr_record *to_remove)
{
    to_remove->prev->next = to_remove->next;

    if (to_remove->next)
        to_remove->next->prev = to_remove->prev;
}

/* Put a block into the free collection of a heap.
*/
void U(into_free_collection)(
    /* Pointer to heap descriptor. */
    U(descriptor) *desc,
    /* Pointer to head record of block. */
    head_record *head_ptr)
{
    ptr_record *ptr_rec_ptr = HEAD_TO_PTR_REC(head_ptr);

    ptr_record *bin_front_ptr =
        U(avl_insert)((U(avl_avl) *) & (desc->avl_tree_root), ptr_rec_ptr);

    if (bin_front_ptr != ptr_rec_ptr)
    {
        /* The block was not inserted into the AVL tree because there is
        ** already a bin for the size of the block. */

        MARK_SUCCESSIVE_BLOCK_IN_FREE_BIN(head_ptr)
        ptr_rec_ptr->self = ptr_rec_ptr;

        /* Make the block the new second block in the bin's doubly-linked
        ** list. */
        ptr_rec_ptr->prev = bin_front_ptr;
        ptr_rec_ptr->next = bin_front_ptr->next;
        bin_front_ptr->next = ptr_rec_ptr;

        if (ptr_rec_ptr->next)
            ptr_rec_ptr->next->prev = ptr_rec_ptr;
    }
    else
        /* Block is first block in new bin. */
        ptr_rec_ptr->next = 0;
}

/* Allocate a block from a given bin.  Returns a pointer to the payload
** of the removed block.  The "last freed" pointer must be null prior
** to calling this function.
*/
void *U(alloc_from_bin)(
    /* Pointer to heap descriptor. */
    U(descriptor) *desc,
    /* Pointer to pointer record of first block in bin. */
    ptr_record *bin_front_ptr,
    /* Number of BAUs needed in the allocated block.  If the block taken
    ** from the bin is significantly larger than the number of BAUs needed,
    ** the "extra" BAUs are split off to form a new free block. */
    U(size_bau) n_baus)
{
    head_record *head_ptr;
    U(size_bau) rem_baus;

    if (bin_front_ptr->next)
    {
        /* There are multiple blocks in this bin.  Use the 2nd block in
        ** the bin to avoid needless change to the AVL tree.
        */

        ptr_record *ptr_rec_ptr = bin_front_ptr->next;
        head_ptr = PTR_REC_TO_HEAD(ptr_rec_ptr);

#ifdef AUDIT_FAIL
        AUDIT_BLOCK(head_ptr)
#endif

        U(dll_remove)(ptr_rec_ptr);
    }
    else
    {
        /* There is only one block in the bin, so it has to be removed
        ** from the AVL tree.
        */

        head_ptr = PTR_REC_TO_HEAD(bin_front_ptr);

        U(avl_remove)(
            (U(avl_avl) *) &(desc->avl_tree_root), BLOCK_BAUS(head_ptr));
    }

    MARK_BLOCK_ALLOCATED(head_ptr)

    rem_baus = BLOCK_BAUS(head_ptr) - n_baus;

    if (rem_baus >= MIN_BLOCK_BAUS)
    {
        /* Since there are enough "extra" BAUs, split them off to form
        ** a new free block.
        */

        head_record *rem_head_ptr =
            (head_record *) BAUS_FORWARD(head_ptr, n_baus);

        /* Change the next block's header to reflect the fact that the
        ** block preceeding it is now smaller.
        */
        SET_PREV_BLOCK_BAUS(
            BAUS_FORWARD(head_ptr, head_ptr->block_size), rem_baus)

        head_ptr->block_size = n_baus;

        rem_head_ptr->previous_block_size = n_baus;
        rem_head_ptr->block_size = rem_baus;

        desc->last_freed = rem_head_ptr;
    }

    return(HEAD_TO_PTR_REC(head_ptr));
}

/* Take a block out of the free collection.
*/
void U(out_of_free_collection)(
    /* Descriptor of heap that block is in. */
    U(descriptor) *desc,
    /* Pointer to head of block to take out of free collection. */
    head_record *head_ptr)
{
    ptr_record *ptr_rec_ptr = HEAD_TO_PTR_REC(head_ptr);

    if (ptr_rec_ptr->self == ptr_rec_ptr)
        /* Block is not the front block in its bin, so all we have to
        ** do is take it out of the bin's doubly-linked list. */
        U(dll_remove)(ptr_rec_ptr);
    else
    {
        ptr_record *next = ptr_rec_ptr->next;

        if (next)
            /* Block is the front block in its bin, and there is at least
            ** one other block in the bin.  Substitute the next block for
            ** the front block. */
            U(avl_subst)((U(avl_avl) *) &(desc->avl_tree_root), next);
        else
            /* Block is the front block in its bin, but there is no other
            ** block in the bin.  Eliminate the bin. */
            U(avl_remove)(
                (U(avl_avl) *) &(desc->avl_tree_root), BLOCK_BAUS(head_ptr));
    }
}

void U(free)(U(descriptor) *desc, void *payload_ptr)
{
    /* Flags if coalesce with adjacent block. */
    int coalesce;

    head_record *fwd_head_ptr;
    head_record *free_head_ptr = PTR_REC_TO_HEAD(payload_ptr);

    desc->num_baus_can_shrink = 0;

#ifdef HMM_AUDIT_FAIL

    AUDIT_BLOCK(free_head_ptr)

    /* Make sure not freeing an already free block. */
    if (!IS_BLOCK_ALLOCATED(free_head_ptr))
        HMM_AUDIT_FAIL

        if (desc->avl_tree_root)
            /* Audit root block in AVL tree. */
            AUDIT_BLOCK(PTR_REC_TO_HEAD(desc->avl_tree_root))

#endif

            fwd_head_ptr =
                (head_record *) BAUS_FORWARD(free_head_ptr, free_head_ptr->block_size);

    if (free_head_ptr->previous_block_size)
    {
        /* Coalesce with backward block if possible. */

        head_record *bkwd_head_ptr =
            (head_record *) BAUS_BACKWARD(
                free_head_ptr, free_head_ptr->previous_block_size);

#ifdef HMM_AUDIT_FAIL
        AUDIT_BLOCK(bkwd_head_ptr)
#endif

        if (bkwd_head_ptr == (head_record *)(desc->last_freed))
        {
            desc->last_freed = 0;
            coalesce = 1;
        }
        else if (IS_BLOCK_ALLOCATED(bkwd_head_ptr))
            coalesce = 0;
        else
        {
            U(out_of_free_collection)(desc, bkwd_head_ptr);
            coalesce = 1;
        }

        if (coalesce)
        {
            bkwd_head_ptr->block_size += free_head_ptr->block_size;
            SET_PREV_BLOCK_BAUS(fwd_head_ptr, BLOCK_BAUS(bkwd_head_ptr))
            free_head_ptr = bkwd_head_ptr;
        }
    }

    if (fwd_head_ptr->block_size == 0)
    {
        /* Block to be freed is last block before dummy end-of-chunk block. */
        desc->end_of_shrinkable_chunk =
            BAUS_FORWARD(fwd_head_ptr, DUMMY_END_BLOCK_BAUS);
        desc->num_baus_can_shrink = BLOCK_BAUS(free_head_ptr);

        if (PREV_BLOCK_BAUS(free_head_ptr) == 0)
            /* Free block is the entire chunk, so shrinking can eliminate
            ** entire chunk including dummy end block. */
            desc->num_baus_can_shrink += DUMMY_END_BLOCK_BAUS;
    }
    else
    {
        /* Coalesce with forward block if possible. */

#ifdef HMM_AUDIT_FAIL
        AUDIT_BLOCK(fwd_head_ptr)
#endif

        if (fwd_head_ptr == (head_record *)(desc->last_freed))
        {
            desc->last_freed = 0;
            coalesce = 1;
        }
        else if (IS_BLOCK_ALLOCATED(fwd_head_ptr))
            coalesce = 0;
        else
        {
            U(out_of_free_collection)(desc, fwd_head_ptr);
            coalesce = 1;
        }

        if (coalesce)
        {
            free_head_ptr->block_size += fwd_head_ptr->block_size;

            fwd_head_ptr =
                (head_record *) BAUS_FORWARD(
                    fwd_head_ptr, BLOCK_BAUS(fwd_head_ptr));

            SET_PREV_BLOCK_BAUS(fwd_head_ptr, BLOCK_BAUS(free_head_ptr))

            if (fwd_head_ptr->block_size == 0)
            {
                /* Coalesced block to be freed is last block before dummy
                ** end-of-chunk block. */
                desc->end_of_shrinkable_chunk =
                    BAUS_FORWARD(fwd_head_ptr, DUMMY_END_BLOCK_BAUS);
                desc->num_baus_can_shrink = BLOCK_BAUS(free_head_ptr);

                if (PREV_BLOCK_BAUS(free_head_ptr) == 0)
                    /* Free block is the entire chunk, so shrinking can
                    ** eliminate entire chunk including dummy end block. */
                    desc->num_baus_can_shrink += DUMMY_END_BLOCK_BAUS;
            }
        }
    }

    if (desc->last_freed)
    {
        /* There is a last freed block, but it is not adjacent to the
        ** block being freed by this call to free, so put the last
        ** freed block into the free collection.
        */

#ifdef HMM_AUDIT_FAIL
        AUDIT_BLOCK(desc->last_freed)
#endif

        U(into_free_collection)(desc, (head_record *)(desc->last_freed));
    }

    desc->last_freed = free_head_ptr;
}

void U(new_chunk)(U(descriptor) *desc, void *start, U(size_bau) n_baus)
{
#ifdef HMM_AUDIT_FAIL

    if (desc->avl_tree_root)
        /* Audit root block in AVL tree. */
        AUDIT_BLOCK(PTR_REC_TO_HEAD(desc->avl_tree_root))
#endif

#undef HEAD_PTR
#define HEAD_PTR ((head_record *) start)

        /* Make the chunk one big free block followed by a dummy end block.
        */

        n_baus -= DUMMY_END_BLOCK_BAUS;

    HEAD_PTR->previous_block_size = 0;
    HEAD_PTR->block_size = n_baus;

    U(into_free_collection)(desc, HEAD_PTR);

    /* Set up the dummy end block. */
    start = BAUS_FORWARD(start, n_baus);
    HEAD_PTR->previous_block_size = n_baus;
    HEAD_PTR->block_size = 0;

#undef HEAD_PTR
}

#ifdef HMM_AUDIT_FAIL

/* Function that does audit fail actions defined my preprocessor symbol,
** and returns a dummy integer value.
*/
int U(audit_block_fail_dummy_return)(void)
{
    HMM_AUDIT_FAIL

    /* Dummy return. */
    return(0);
}

#endif

/* AVL Tree instantiation. */

#ifdef HMM_AUDIT_FAIL

/* The AVL tree generic package passes an ACCESS of 1 when it "touches"
** a child node for the first time during a particular operation.  I use
** this feature to audit only one time (per operation) the free blocks
** that are tree nodes.  Since the root node is not a child node, it has
** to be audited directly.
*/

/* The pain you feel while reading these macros will not be in vain.  It
** will remove all doubt from you mind that C++ inline functions are
** a very good thing.
*/

#define AVL_GET_LESS(H, ACCESS) \
    (((ACCESS) ? AUDIT_BLOCK_AS_EXPR(PTR_REC_TO_HEAD(H)) : 0), (H)->self)
#define AVL_GET_GREATER(H, ACCESS) \
    (((ACCESS) ? AUDIT_BLOCK_AS_EXPR(PTR_REC_TO_HEAD(H)) : 0), (H)->prev)

#else

#define AVL_GET_LESS(H, ACCESS) ((H)->self)
#define AVL_GET_GREATER(H, ACCESS) ((H)->prev)

#endif

#define AVL_SET_LESS(H, LH) (H)->self = (LH);
#define AVL_SET_GREATER(H, GH) (H)->prev = (GH);

/*  high bit of high bit of
**  block_size  previous_block_size balance factor
**  ----------- ------------------- --------------
**  0       0           n/a (block allocated)
**  0       1           1
**  1       0           -1
**  1       1           0
*/

#define AVL_GET_BALANCE_FACTOR(H) \
    ((((head_record *) (PTR_REC_TO_HEAD(H)))->block_size & \
      HIGH_BIT_BAU_SIZE) ? \
     (((head_record *) (PTR_REC_TO_HEAD(H)))->previous_block_size & \
      HIGH_BIT_BAU_SIZE ? 0 : -1) : 1)

#define AVL_SET_BALANCE_FACTOR(H, BF) \
    {                         \
        register head_record *p =               \
                                                (head_record *) PTR_REC_TO_HEAD(H);       \
        register int bal_f = (BF);              \
        \
        if (bal_f <= 0)                 \
            p->block_size |= HIGH_BIT_BAU_SIZE;       \
        else                        \
            p->block_size &= ~HIGH_BIT_BAU_SIZE;      \
        if (bal_f >= 0)                 \
            p->previous_block_size |= HIGH_BIT_BAU_SIZE;  \
        else                        \
            p->previous_block_size &= ~HIGH_BIT_BAU_SIZE; \
    }

#define COMPARE_KEY_KEY(K1, K2) ((K1) == (K2) ? 0 : ((K1) > (K2) ? 1 : -1))

#define AVL_COMPARE_KEY_NODE(K, H) \
    COMPARE_KEY_KEY(K, BLOCK_BAUS(PTR_REC_TO_HEAD(H)))

#define AVL_COMPARE_NODE_NODE(H1, H2) \
    COMPARE_KEY_KEY(BLOCK_BAUS(PTR_REC_TO_HEAD(H1)), \
                    BLOCK_BAUS(PTR_REC_TO_HEAD(H2)))

#define AVL_NULL ((ptr_record *) 0)

#define AVL_IMPL_MASK \
    ( AVL_IMPL_INSERT | AVL_IMPL_SEARCH | AVL_IMPL_REMOVE | AVL_IMPL_SUBST )

#include "cavl_impl.h"