blob: 0cacc3f8fcd0a9bcf640d08863f38846a9e31918 [file] [log] [blame]
/*
* Copyright (c) 2010 The VP8 project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license and patent
* grant that can be found in the LICENSE file in the root of the source
* tree. 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"