void
btree_depth_first_traversal_iterative(struct b_tree_node_t *root)
{
struct b_tree_node_t *node;
lifo_t lifo;
lifo_init(&lifo);
lifo_push(&lifo, root);
do {
root = lifo_pop(&lifo);
if (root == NULL) {
continue;
}
if (root->right) {
lifo_push(&lifo, root->right);
}
if (root->left) {
lifo_push(&lifo, root->left);
}
} while (root);
}
void hwtimer_init_comp(uint32_t fcpu)
{
hwtimer_arch_init(multiplexer, fcpu);
lifo_init(lifo, HWTIMER_MAXTIMERS);
for (int i = 0; i < HWTIMER_MAXTIMERS; i++) {
lifo_insert(lifo, i);
}
}
void
mempool_create_with_order(struct mempool *pool, struct slab_cache *cache,
uint32_t objsize, uint8_t order)
{
assert(order <= cache->order_max);
lifo_init(&pool->link);
lifo_init(&pool->delayed);
pool->cache = cache;
slab_list_create(&pool->slabs);
mslab_tree_new(&pool->free_slabs);
pool->spare = NULL;
pool->objsize = objsize;
pool->slab_order = order;
/* Total size of slab */
uint32_t slab_size = slab_order_size(pool->cache, pool->slab_order);
/* Calculate how many objects will actually fit in a slab. */
pool->objcount = (slab_size - mslab_sizeof()) / objsize;
assert(pool->objcount);
pool->objoffset = slab_size - pool->objcount * pool->objsize;
}
/** Initialize the small allocator. */
void
small_alloc_create(struct small_alloc *alloc, struct slab_cache *cache,
uint32_t objsize_min, float alloc_factor)
{
alloc->cache = cache;
/* Align sizes. */
objsize_min = small_align(objsize_min, STEP_SIZE);
/* Make sure at least 4 largest objects can fit in a slab. */
alloc->objsize_max =
mempool_objsize_max(slab_order_size(cache, cache->order_max));
assert(alloc->objsize_max > objsize_min + STEP_POOL_MAX * STEP_SIZE);
struct mempool *step_pool;
for (step_pool = alloc->step_pools;
step_pool < alloc->step_pools + STEP_POOL_MAX;
step_pool++) {
mempool_create(step_pool, alloc->cache, objsize_min);
objsize_min += STEP_SIZE;
}
alloc->step_pool_objsize_max = (step_pool - 1)->objsize;
if (alloc_factor > 2.0)
alloc_factor = 2.0;
/*
* Correct the user-supplied alloc_factor to ensure that
* it actually produces growing object sizes.
*/
if (alloc->step_pool_objsize_max * alloc_factor <
alloc->step_pool_objsize_max + STEP_SIZE) {
alloc_factor =
(alloc->step_pool_objsize_max + STEP_SIZE + 0.5)/
alloc->step_pool_objsize_max;
}
alloc->factor = alloc_factor;
/* Initialize the factored pool cache. */
struct factor_pool *factor_pool = alloc->factor_pool_cache;
do {
factor_pool->next = factor_pool + 1;
factor_pool++;
} while (factor_pool !=
alloc->factor_pool_cache + FACTOR_POOL_MAX - 1);
factor_pool->next = NULL;
alloc->factor_pool_next = alloc->factor_pool_cache;
factor_tree_new(&alloc->factor_pools);
(void) factor_pool_create(alloc, NULL, alloc->objsize_max);
lifo_init(&alloc->delayed);
alloc->is_delayed_free_mode = false;
}
int main()
{
int array[5];
lifo_init(array, 4);
lifo_insert(array, 2);
lifo_insert(array, 1);
lifo_insert(array, 3);
lifo_insert(array, 0);
lifo_insert(array, 3);
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
printf("get: %i\n", lifo_get(array));
return 0;
}
static void set_up(void)
{
lifo_init(lifo, TEST_LIFO_MAX_ELEM);
}
