xuos
/
tobudos-kernel
2
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
tobudos-kernel/core/tos_binary_heap.c

297 lines
8.4 KiB
C
Raw Blame History

/*----------------------------------------------------------------------------
* Tencent is pleased to support the open source community by making TencentOS
* available.
*
* Copyright (C) 2019 THL A29 Limited, a Tencent company. All rights reserved.
* If you have downloaded a copy of the TencentOS binary from Tencent, please
* note that the TencentOS binary is licensed under the BSD 3-Clause License.
*
* If you have downloaded a copy of the TencentOS source code from Tencent,
* please note that TencentOS source code is licensed under the BSD 3-Clause
* License, except for the third-party components listed below which are
* subject to different license terms. Your integration of TencentOS into your
* own projects may require compliance with the BSD 3-Clause License, as well
* as the other licenses applicable to the third-party components included
* within TencentOS.
*---------------------------------------------------------------------------*/
#include "tos_k.h"
__STATIC_INLINE__ void bin_heap_item_copy_to(k_bin_heap_t *bin_heap, void *item_out, size_t *item_size)
{
memcpy(item_out, BIN_HEAP_FIRST_ITEM(bin_heap), bin_heap->item_size);
if (item_size) {
*item_size = bin_heap->item_size;
}
}
__STATIC_INLINE__ void bin_heap_item_copy_from(k_bin_heap_t *bin_heap, void *item_in)
{
memcpy(BIN_HEAP_LAST_ITEM(bin_heap), item_in, bin_heap->item_size);
}
__STATIC_INLINE__ void bin_heap_item_increase(k_bin_heap_t *bin_heap)
{
++bin_heap->total;
}
__STATIC_INLINE__ void bin_heap_item_decrease(k_bin_heap_t *bin_heap)
{
--bin_heap->total;
}
__STATIC__ void bin_heap_do_percolate_up(k_bin_heap_t *bin_heap, uint16_t hole, void *item_backup)
{
k_bin_heap_cmp cmp;
size_t item_size;
uint16_t parent, top;
void *hole_item, *parent_item;
top = 0u;
parent = BIN_HEAP_PARENT(hole);
cmp = bin_heap->cmp;
item_size = bin_heap->item_size;
hole_item = BIN_HEAP_THE_ITEM(bin_heap, hole);
parent_item = BIN_HEAP_THE_ITEM(bin_heap, parent);
while (hole > top && cmp(item_backup, parent_item)) {
memcpy(hole_item, parent_item, item_size);
hole = parent;
parent = BIN_HEAP_PARENT(hole);
hole_item = BIN_HEAP_THE_ITEM(bin_heap, hole);
parent_item = BIN_HEAP_THE_ITEM(bin_heap, parent);
}
hole_item = BIN_HEAP_THE_ITEM(bin_heap, hole);
memcpy(hole_item, item_backup, item_size);
}
__STATIC__ void bin_heap_percolate_up(k_bin_heap_t *bin_heap, void *item_backup)
{
bin_heap_do_percolate_up(bin_heap, bin_heap->total, item_backup);
}
__STATIC__ void bin_heap_percolate_down(k_bin_heap_t *bin_heap)
{
k_bin_heap_cmp cmp;
size_t item_size;
uint16_t lchild, rchild, the_child, hole;
void *hole_item, *rchild_item, *lchild_item, *the_child_item;
hole = 0u;
rchild = BIN_HEAP_RCHILD(hole);
lchild = BIN_HEAP_LSIBLING(rchild);
the_child = rchild;
cmp = bin_heap->cmp;
item_size = bin_heap->item_size;
hole_item = BIN_HEAP_THE_ITEM(bin_heap, hole);
rchild_item = BIN_HEAP_THE_ITEM(bin_heap, rchild);
lchild_item = BIN_HEAP_THE_ITEM(bin_heap, lchild);
while (the_child < bin_heap->total) {
if (cmp(lchild_item, rchild_item)) {
the_child = lchild;
}
the_child_item = BIN_HEAP_THE_ITEM(bin_heap, the_child);
memcpy(hole_item, the_child_item, item_size);
hole = the_child;
the_child = BIN_HEAP_RCHILD(the_child);
rchild = the_child;
lchild = BIN_HEAP_LSIBLING(rchild);
hole_item = BIN_HEAP_THE_ITEM(bin_heap, hole);
rchild_item = BIN_HEAP_THE_ITEM(bin_heap, rchild);
lchild_item = BIN_HEAP_THE_ITEM(bin_heap, lchild);
}
if (the_child == bin_heap->total) {
memcpy(hole_item, lchild_item, item_size);
hole = lchild;
hole_item = BIN_HEAP_THE_ITEM(bin_heap, hole);
}
bin_heap_do_percolate_up(bin_heap, hole, BIN_HEAP_LAST_ITEM(bin_heap));
}
__API__ k_err_t tos_bin_heap_create(k_bin_heap_t *bin_heap, void *pool, size_t item_cnt, size_t item_size, k_bin_heap_cmp cmp)
{
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_PTR_SANITY_CHECK(pool);
TOS_PTR_SANITY_CHECK(cmp);
bin_heap->total = 0;
bin_heap->cmp = cmp;
bin_heap->item_size = item_size;
bin_heap->item_cnt = item_cnt;
bin_heap->pool = (uint8_t *)pool;
TOS_OBJ_INIT(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
knl_object_alloc_set_static(&bin_heap->knl_obj);
return K_ERR_NONE;
}
__API__ k_err_t tos_bin_heap_destroy(k_bin_heap_t *bin_heap)
{
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
if (!knl_object_alloc_is_static(&bin_heap->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
bin_heap->total = 0;
bin_heap->cmp = K_NULL;
bin_heap->item_size = 0;
bin_heap->item_cnt = 0;
bin_heap->pool = K_NULL;
TOS_OBJ_DEINIT(bin_heap);
knl_object_alloc_reset(&bin_heap->knl_obj);
return K_ERR_NONE;
}
__API__ k_err_t tos_bin_heap_create_dyn(k_bin_heap_t *bin_heap, size_t item_cnt, size_t item_size, k_bin_heap_cmp cmp)
{
void *pool;
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_PTR_SANITY_CHECK(cmp);
pool = tos_mmheap_alloc(item_cnt * item_size);
if (!pool) {
return K_ERR_OUT_OF_MEMORY;
}
bin_heap->total = 0;
bin_heap->cmp = cmp;
bin_heap->item_size = item_size;
bin_heap->item_cnt = item_cnt;
bin_heap->pool = (uint8_t *)pool;
TOS_OBJ_INIT(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
knl_object_alloc_set_dynamic(&bin_heap->knl_obj);
return K_ERR_NONE;
}
__API__ k_err_t tos_bin_heap_destroy_dyn(k_bin_heap_t *bin_heap)
{
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
if (!knl_object_alloc_is_dynamic(&bin_heap->knl_obj)) {
return K_ERR_OBJ_INVALID_ALLOC_TYPE;
}
tos_mmheap_free(bin_heap->pool);
bin_heap->total = 0;
bin_heap->cmp = K_NULL;
bin_heap->item_size = 0;
bin_heap->item_cnt = 0;
bin_heap->pool = K_NULL;
TOS_OBJ_DEINIT(bin_heap);
knl_object_alloc_reset(&bin_heap->knl_obj);
return K_ERR_NONE;
}
__API__ k_err_t tos_bin_heap_push(k_bin_heap_t *bin_heap, void *item, size_t item_size)
{
TOS_CPU_CPSR_ALLOC();
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_PTR_SANITY_CHECK(item);
TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
if (item_size != bin_heap->item_size) {
return K_ERR_BIN_HEAP_ITEM_SIZE_NOT_MATCH;
}
if (tos_bin_heap_is_full(bin_heap)) {
return K_ERR_BIN_HEAP_FULL;
}
TOS_CPU_INT_DISABLE();
bin_heap_item_copy_from(bin_heap, item);
bin_heap_percolate_up(bin_heap, item);
bin_heap_item_increase(bin_heap);
TOS_CPU_INT_ENABLE();
return K_ERR_NONE;
}
__API__ k_err_t tos_bin_heap_pop(k_bin_heap_t *bin_heap, void *item, size_t *item_size)
{
TOS_CPU_CPSR_ALLOC();
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_PTR_SANITY_CHECK(item);
TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
TOS_CPU_INT_DISABLE();
if (tos_bin_heap_is_empty(bin_heap)) {
TOS_CPU_INT_ENABLE();
return K_ERR_BIN_HEAP_EMPTY;
}
bin_heap_item_copy_to(bin_heap, item, item_size);
bin_heap_item_decrease(bin_heap);
bin_heap_percolate_down(bin_heap);
TOS_CPU_INT_ENABLE();
return K_ERR_NONE;
}
__API__ k_err_t tos_bin_heap_flush(k_bin_heap_t *bin_heap)
{
TOS_CPU_CPSR_ALLOC();
TOS_PTR_SANITY_CHECK(bin_heap);
TOS_OBJ_VERIFY(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP);
TOS_CPU_INT_DISABLE();
bin_heap->total = 0;
TOS_CPU_INT_ENABLE();
return K_ERR_NONE;
}
__API__ int tos_bin_heap_is_empty(k_bin_heap_t *bin_heap)
{
TOS_CPU_CPSR_ALLOC();
int is_empty = K_FALSE;
TOS_PTR_SANITY_CHECK_RC(bin_heap, K_FALSE);
TOS_OBJ_VERIFY_RC(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP, K_FALSE);
TOS_CPU_INT_DISABLE();
is_empty = (bin_heap->total == 0);
TOS_CPU_INT_ENABLE();
return is_empty;
}
__API__ int tos_bin_heap_is_full(k_bin_heap_t *bin_heap)
{
TOS_CPU_CPSR_ALLOC();
int is_full = K_FALSE;
TOS_PTR_SANITY_CHECK_RC(bin_heap, K_FALSE);
TOS_OBJ_VERIFY_RC(bin_heap, KNL_OBJ_TYPE_BINARY_HEAP, K_FALSE);
TOS_CPU_INT_DISABLE();
is_full = (bin_heap->total == bin_heap->item_cnt ? K_TRUE : K_FALSE);
TOS_CPU_INT_ENABLE();
return is_full;
}
Reference in New Issue View Git Blame Copy Permalink