mirror of
https://github.com/FreeRTOS/FreeRTOS-Kernel.git
synced 2025-09-10 08:07:46 -04:00
Renamed parent_group
I renamed parent_group to cluster_parent_group.
This commit is contained in:
Sven Bieg
parent
d024d75ce4
commit
4ee0992579
2 changed files with 191 additions and 191 deletions
|
|
@ -346,18 +346,18 @@ cluster_group_t get;
|
|||
get.value=group->value;
|
||||
if(get.level==0)
|
||||
return get.child_count;
|
||||
parent_group_t* parent_group=(parent_group_t*)group;
|
||||
return parent_group->item_count;
|
||||
cluster_parent_group_t* cluster_parent_group=(cluster_parent_group_t*)group;
|
||||
return cluster_parent_group->item_count;
|
||||
}
|
||||
|
||||
|
||||
//==============
|
||||
// Parent-Group
|
||||
//==============
|
||||
//======================
|
||||
// Cluster-Parent-Group
|
||||
//======================
|
||||
|
||||
// Access
|
||||
|
||||
uint16_t parent_group_get_group(parent_group_t* group, size_t* pos)
|
||||
uint16_t cluster_parent_group_get_group(cluster_parent_group_t* group, size_t* pos)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
for(uint16_t u=0; u<child_count; u++)
|
||||
|
|
@ -370,7 +370,7 @@ for(uint16_t u=0; u<child_count; u++)
|
|||
return CLUSTER_GROUP_SIZE;
|
||||
}
|
||||
|
||||
int16_t parent_group_get_nearest_space(parent_group_t* group, int16_t pos)
|
||||
int16_t cluster_parent_group_get_nearest_space(cluster_parent_group_t* group, int16_t pos)
|
||||
{
|
||||
int16_t child_count=(int16_t)cluster_group_get_child_count((cluster_group_t*)group);
|
||||
int16_t before=pos-1;
|
||||
|
|
@ -398,7 +398,7 @@ return -1;
|
|||
|
||||
// Modification
|
||||
|
||||
void parent_group_append_groups(parent_group_t* group, cluster_group_t* const* append, uint16_t count)
|
||||
void cluster_parent_group_append_groups(cluster_parent_group_t* group, cluster_group_t* const* append, uint16_t count)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
configASSERT(child_count+count<=CLUSTER_GROUP_SIZE);
|
||||
|
|
@ -410,7 +410,7 @@ for(uint16_t u=0; u<count; u++)
|
|||
cluster_group_set_child_count((cluster_group_t*)group, child_count+count);
|
||||
}
|
||||
|
||||
void parent_group_insert_groups(parent_group_t* group, uint16_t at, cluster_group_t* const* insert, uint16_t count)
|
||||
void cluster_parent_group_insert_groups(cluster_parent_group_t* group, uint16_t at, cluster_group_t* const* insert, uint16_t count)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
configASSERT(at<=child_count);
|
||||
|
|
@ -425,7 +425,7 @@ for(uint16_t u=0; u<count; u++)
|
|||
cluster_group_set_child_count((cluster_group_t*)group, child_count+count);
|
||||
}
|
||||
|
||||
void parent_group_remove_group(heap_handle_t heap, parent_group_t* group, uint16_t at)
|
||||
void cluster_parent_group_remove_group(heap_handle_t heap, cluster_parent_group_t* group, uint16_t at)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
configASSERT(at<child_count);
|
||||
|
|
@ -438,7 +438,7 @@ cluster_group_set_child_count((cluster_group_t*)group, child_count-1);
|
|||
heap_free_to_cache(heap, child);
|
||||
}
|
||||
|
||||
void parent_group_remove_groups(parent_group_t* group, uint16_t at, uint16_t count)
|
||||
void cluster_parent_group_remove_groups(cluster_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
configASSERT(at+count<=child_count);
|
||||
|
|
@ -460,14 +460,14 @@ size_t block_map_group_get_first_size(block_map_group_t* group)
|
|||
{
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return block_map_item_group_get_first_size((block_map_item_group_t*)group);
|
||||
return ((block_map_parent_group_t*)group)->first_size;
|
||||
return ((block_map_cluster_parent_group_t*)group)->first_size;
|
||||
}
|
||||
|
||||
block_map_item_t* block_map_group_get_item(block_map_group_t* group, size_t size)
|
||||
{
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return block_map_item_group_get_item((block_map_item_group_t*)group, size);
|
||||
return block_map_parent_group_get_item((block_map_parent_group_t*)group, size);
|
||||
return block_map_cluster_parent_group_get_item((block_map_cluster_parent_group_t*)group, size);
|
||||
}
|
||||
|
||||
size_t block_map_group_get_last_size(block_map_group_t* group)
|
||||
|
|
@ -476,7 +476,7 @@ if(group==NULL)
|
|||
return 0;
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return block_map_item_group_get_last_size((block_map_item_group_t*)group);
|
||||
return ((block_map_parent_group_t*)group)->last_size;
|
||||
return ((block_map_cluster_parent_group_t*)group)->last_size;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -492,7 +492,7 @@ if(cluster_group_get_level(group)==0)
|
|||
}
|
||||
else
|
||||
{
|
||||
added=block_map_parent_group_add_block(heap, (block_map_parent_group_t*)group, info, again);
|
||||
added=block_map_cluster_parent_group_add_block(heap, (block_map_cluster_parent_group_t*)group, info, again);
|
||||
}
|
||||
cluster_group_set_locked((cluster_group_t*)group, false);
|
||||
return added;
|
||||
|
|
@ -503,14 +503,14 @@ bool block_map_group_get_block(heap_handle_t heap, block_map_group_t* group, siz
|
|||
bool passive=cluster_group_is_locked((cluster_group_t*)group);
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return block_map_item_group_get_block(heap, (block_map_item_group_t*)group, min_size, info, passive);
|
||||
return block_map_parent_group_get_block(heap, (block_map_parent_group_t*)group, min_size, info, passive);
|
||||
return block_map_cluster_parent_group_get_block(heap, (block_map_cluster_parent_group_t*)group, min_size, info, passive);
|
||||
}
|
||||
|
||||
bool block_map_group_remove_block(heap_handle_t heap, block_map_group_t* group, heap_block_info_t const* info)
|
||||
{
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return block_map_item_group_remove_block(heap, (block_map_item_group_t*)group, info);
|
||||
return block_map_parent_group_remove_block(heap, (block_map_parent_group_t*)group, info);
|
||||
return block_map_cluster_parent_group_remove_block(heap, (block_map_cluster_parent_group_t*)group, info);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -745,9 +745,9 @@ cluster_group_set_child_count((cluster_group_t*)group, child_count-count);
|
|||
|
||||
// Con-/Destructors
|
||||
|
||||
block_map_parent_group_t* block_map_parent_group_create(heap_handle_t heap, uint16_t level)
|
||||
block_map_cluster_parent_group_t* block_map_cluster_parent_group_create(heap_handle_t heap, uint16_t level)
|
||||
{
|
||||
block_map_parent_group_t* group=(block_map_parent_group_t*)heap_alloc_internal(heap, sizeof(block_map_parent_group_t));
|
||||
block_map_cluster_parent_group_t* group=(block_map_cluster_parent_group_t*)heap_alloc_internal(heap, sizeof(block_map_cluster_parent_group_t));
|
||||
if(group==NULL)
|
||||
return NULL;
|
||||
cluster_group_init((cluster_group_t*)group, level, 0);
|
||||
|
|
@ -757,9 +757,9 @@ group->item_count=0;
|
|||
return group;
|
||||
}
|
||||
|
||||
block_map_parent_group_t* block_map_parent_group_create_with_child(heap_handle_t heap, block_map_group_t* child)
|
||||
block_map_cluster_parent_group_t* block_map_cluster_parent_group_create_with_child(heap_handle_t heap, block_map_group_t* child)
|
||||
{
|
||||
block_map_parent_group_t* group=(block_map_parent_group_t*)heap_alloc_internal(heap, sizeof(block_map_parent_group_t));
|
||||
block_map_cluster_parent_group_t* group=(block_map_cluster_parent_group_t*)heap_alloc_internal(heap, sizeof(block_map_cluster_parent_group_t));
|
||||
if(group==NULL)
|
||||
return NULL;
|
||||
uint16_t child_level=cluster_group_get_level((cluster_group_t*)child);
|
||||
|
|
@ -774,15 +774,15 @@ return group;
|
|||
|
||||
// Access
|
||||
|
||||
block_map_item_t* block_map_parent_group_get_item(block_map_parent_group_t* group, size_t size)
|
||||
block_map_item_t* block_map_cluster_parent_group_get_item(block_map_cluster_parent_group_t* group, size_t size)
|
||||
{
|
||||
uint16_t pos=0;
|
||||
uint16_t count=block_map_parent_group_get_item_pos(group, size, &pos, true);
|
||||
uint16_t count=block_map_cluster_parent_group_get_item_pos(group, size, &pos, true);
|
||||
configASSERT(count>0);
|
||||
return block_map_group_get_item(group->children[pos], size);
|
||||
}
|
||||
|
||||
uint16_t block_map_parent_group_get_item_pos(block_map_parent_group_t* group, size_t size, uint16_t* pos_ptr, bool must_exist)
|
||||
uint16_t block_map_cluster_parent_group_get_item_pos(block_map_cluster_parent_group_t* group, size_t size, uint16_t* pos_ptr, bool must_exist)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
uint16_t pos=0;
|
||||
|
|
@ -820,24 +820,24 @@ return 2;
|
|||
|
||||
// Modification
|
||||
|
||||
bool block_map_parent_group_add_block(heap_handle_t heap, block_map_parent_group_t* group, heap_block_info_t const* info, bool again)
|
||||
bool block_map_cluster_parent_group_add_block(heap_handle_t heap, block_map_cluster_parent_group_t* group, heap_block_info_t const* info, bool again)
|
||||
{
|
||||
if(!block_map_parent_group_add_block_internal(heap, group, info, again))
|
||||
if(!block_map_cluster_parent_group_add_block_internal(heap, group, info, again))
|
||||
return false;
|
||||
group->item_count++;
|
||||
block_map_parent_group_update_bounds(group);
|
||||
block_map_cluster_parent_group_update_bounds(group);
|
||||
if(cluster_group_is_dirty((cluster_group_t*)group))
|
||||
{
|
||||
block_map_parent_group_combine_children(heap, group);
|
||||
block_map_cluster_parent_group_combine_children(heap, group);
|
||||
cluster_group_set_dirty((cluster_group_t*)group, false);
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
bool block_map_parent_group_add_block_internal(heap_handle_t heap, block_map_parent_group_t* group, heap_block_info_t const* info, bool again)
|
||||
bool block_map_cluster_parent_group_add_block_internal(heap_handle_t heap, block_map_cluster_parent_group_t* group, heap_block_info_t const* info, bool again)
|
||||
{
|
||||
uint16_t pos=0;
|
||||
uint16_t count=block_map_parent_group_get_item_pos(group, info->size, &pos, false);
|
||||
uint16_t count=block_map_cluster_parent_group_get_item_pos(group, info->size, &pos, false);
|
||||
if(!again)
|
||||
{
|
||||
for(uint16_t u=0; u<count; u++)
|
||||
|
|
@ -845,9 +845,9 @@ if(!again)
|
|||
if(block_map_group_add_block(heap, group->children[pos+u], info, false))
|
||||
return true;
|
||||
}
|
||||
if(block_map_parent_group_shift_children(group, pos, count))
|
||||
if(block_map_cluster_parent_group_shift_children(group, pos, count))
|
||||
{
|
||||
count=block_map_parent_group_get_item_pos(group, info->size, &pos, false);
|
||||
count=block_map_cluster_parent_group_get_item_pos(group, info->size, &pos, false);
|
||||
for(uint16_t u=0; u<count; u++)
|
||||
{
|
||||
if(block_map_group_add_block(heap, group->children[pos+u], info, false))
|
||||
|
|
@ -855,9 +855,9 @@ if(!again)
|
|||
}
|
||||
}
|
||||
}
|
||||
if(!block_map_parent_group_split_child(heap, group, pos))
|
||||
if(!block_map_cluster_parent_group_split_child(heap, group, pos))
|
||||
return false;
|
||||
count=block_map_parent_group_get_item_pos(group, info->size, &pos, false);
|
||||
count=block_map_cluster_parent_group_get_item_pos(group, info->size, &pos, false);
|
||||
for(uint16_t u=0; u<count; u++)
|
||||
{
|
||||
if(block_map_group_add_block(heap, group->children[pos+u], info, true))
|
||||
|
|
@ -866,18 +866,18 @@ for(uint16_t u=0; u<count; u++)
|
|||
return false;
|
||||
}
|
||||
|
||||
void block_map_parent_group_append_groups(block_map_parent_group_t* group, block_map_group_t* const* append, uint16_t count)
|
||||
void block_map_cluster_parent_group_append_groups(block_map_cluster_parent_group_t* group, block_map_group_t* const* append, uint16_t count)
|
||||
{
|
||||
parent_group_append_groups((parent_group_t*)group, (cluster_group_t* const*)append, count);
|
||||
block_map_parent_group_update_bounds(group);
|
||||
cluster_parent_group_append_groups((cluster_parent_group_t*)group, (cluster_group_t* const*)append, count);
|
||||
block_map_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
bool block_map_parent_group_combine_child(heap_handle_t heap, block_map_parent_group_t* group, uint16_t pos)
|
||||
bool block_map_cluster_parent_group_combine_child(heap_handle_t heap, block_map_cluster_parent_group_t* group, uint16_t pos)
|
||||
{
|
||||
uint16_t count=cluster_group_get_child_count(group->children[pos]);
|
||||
if(count==0)
|
||||
{
|
||||
parent_group_remove_group(heap, (parent_group_t*)group, pos);
|
||||
cluster_parent_group_remove_group(heap, (cluster_parent_group_t*)group, pos);
|
||||
return true;
|
||||
}
|
||||
if(pos>0)
|
||||
|
|
@ -885,8 +885,8 @@ if(pos>0)
|
|||
uint16_t before=cluster_group_get_child_count(group->children[pos-1]);
|
||||
if(count+before<=CLUSTER_GROUP_SIZE)
|
||||
{
|
||||
block_map_parent_group_move_children(group, pos, pos-1, count);
|
||||
parent_group_remove_group(heap, (parent_group_t*)group, pos);
|
||||
block_map_cluster_parent_group_move_children(group, pos, pos-1, count);
|
||||
cluster_parent_group_remove_group(heap, (cluster_parent_group_t*)group, pos);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -896,20 +896,20 @@ if(pos+1<child_count)
|
|||
uint16_t after=cluster_group_get_child_count(group->children[pos+1]);
|
||||
if(count+after<=CLUSTER_GROUP_SIZE)
|
||||
{
|
||||
block_map_parent_group_move_children(group, pos+1, pos, after);
|
||||
parent_group_remove_group(heap, (parent_group_t*)group, pos+1);
|
||||
block_map_cluster_parent_group_move_children(group, pos+1, pos, after);
|
||||
cluster_parent_group_remove_group(heap, (cluster_parent_group_t*)group, pos+1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void block_map_parent_group_combine_children(heap_handle_t heap, block_map_parent_group_t* group)
|
||||
void block_map_cluster_parent_group_combine_children(heap_handle_t heap, block_map_cluster_parent_group_t* group)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
for(uint16_t pos=0; pos<child_count; )
|
||||
{
|
||||
if(block_map_parent_group_combine_child(heap, group, pos))
|
||||
if(block_map_cluster_parent_group_combine_child(heap, group, pos))
|
||||
{
|
||||
child_count--;
|
||||
}
|
||||
|
|
@ -920,10 +920,10 @@ for(uint16_t pos=0; pos<child_count; )
|
|||
}
|
||||
}
|
||||
|
||||
bool block_map_parent_group_get_block(heap_handle_t heap, block_map_parent_group_t* group, size_t min_size, heap_block_info_t* info, bool passive)
|
||||
bool block_map_cluster_parent_group_get_block(heap_handle_t heap, block_map_cluster_parent_group_t* group, size_t min_size, heap_block_info_t* info, bool passive)
|
||||
{
|
||||
uint16_t pos=0;
|
||||
uint16_t count=block_map_parent_group_get_item_pos(group, min_size, &pos, false);
|
||||
uint16_t count=block_map_cluster_parent_group_get_item_pos(group, min_size, &pos, false);
|
||||
configASSERT(count>0);
|
||||
if(count==2)
|
||||
pos++;
|
||||
|
|
@ -935,36 +935,36 @@ if(passive)
|
|||
}
|
||||
else
|
||||
{
|
||||
block_map_parent_group_combine_child(heap, group, pos);
|
||||
block_map_cluster_parent_group_combine_child(heap, group, pos);
|
||||
}
|
||||
group->item_count--;
|
||||
block_map_parent_group_update_bounds(group);
|
||||
block_map_cluster_parent_group_update_bounds(group);
|
||||
return true;
|
||||
}
|
||||
|
||||
void block_map_parent_group_insert_groups(block_map_parent_group_t* group, uint16_t at, block_map_group_t* const* insert, uint16_t count)
|
||||
void block_map_cluster_parent_group_insert_groups(block_map_cluster_parent_group_t* group, uint16_t at, block_map_group_t* const* insert, uint16_t count)
|
||||
{
|
||||
parent_group_insert_groups((parent_group_t*)group, at, (cluster_group_t* const*)insert, count);
|
||||
block_map_parent_group_update_bounds(group);
|
||||
cluster_parent_group_insert_groups((cluster_parent_group_t*)group, at, (cluster_group_t* const*)insert, count);
|
||||
block_map_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
void block_map_parent_group_move_children(block_map_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count)
|
||||
void block_map_cluster_parent_group_move_children(block_map_cluster_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count)
|
||||
{
|
||||
uint16_t level=cluster_group_get_level((cluster_group_t*)group);
|
||||
if(level>1)
|
||||
{
|
||||
block_map_parent_group_t* src=(block_map_parent_group_t*)group->children[from];
|
||||
block_map_parent_group_t* dst=(block_map_parent_group_t*)group->children[to];
|
||||
block_map_cluster_parent_group_t* src=(block_map_cluster_parent_group_t*)group->children[from];
|
||||
block_map_cluster_parent_group_t* dst=(block_map_cluster_parent_group_t*)group->children[to];
|
||||
if(from>to)
|
||||
{
|
||||
block_map_parent_group_append_groups(dst, src->children, count);
|
||||
block_map_parent_group_remove_groups(src, 0, count);
|
||||
block_map_cluster_parent_group_append_groups(dst, src->children, count);
|
||||
block_map_cluster_parent_group_remove_groups(src, 0, count);
|
||||
}
|
||||
else
|
||||
{
|
||||
uint16_t src_count=cluster_group_get_child_count((cluster_group_t*)src);
|
||||
block_map_parent_group_insert_groups(dst, 0, &src->children[src_count-count], count);
|
||||
block_map_parent_group_remove_groups(src, src_count-count, count);
|
||||
block_map_cluster_parent_group_insert_groups(dst, 0, &src->children[src_count-count], count);
|
||||
block_map_cluster_parent_group_remove_groups(src, src_count-count, count);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -985,53 +985,53 @@ else
|
|||
}
|
||||
}
|
||||
|
||||
void block_map_parent_group_move_empty_slot(block_map_parent_group_t* group, uint16_t from, uint16_t to)
|
||||
void block_map_cluster_parent_group_move_empty_slot(block_map_cluster_parent_group_t* group, uint16_t from, uint16_t to)
|
||||
{
|
||||
if(from<to)
|
||||
{
|
||||
for(uint16_t u=from; u<to; u++)
|
||||
block_map_parent_group_move_children(group, u+1, u, 1);
|
||||
block_map_cluster_parent_group_move_children(group, u+1, u, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
for(uint16_t u=from; u>to; u--)
|
||||
block_map_parent_group_move_children(group, u-1, u, 1);
|
||||
block_map_cluster_parent_group_move_children(group, u-1, u, 1);
|
||||
}
|
||||
}
|
||||
|
||||
bool block_map_parent_group_remove_block(heap_handle_t heap, block_map_parent_group_t* group, heap_block_info_t const* info)
|
||||
bool block_map_cluster_parent_group_remove_block(heap_handle_t heap, block_map_cluster_parent_group_t* group, heap_block_info_t const* info)
|
||||
{
|
||||
uint16_t pos=0;
|
||||
uint16_t count=block_map_parent_group_get_item_pos(group, info->size, &pos, true);
|
||||
uint16_t count=block_map_cluster_parent_group_get_item_pos(group, info->size, &pos, true);
|
||||
configASSERT(count==1);
|
||||
if(block_map_group_remove_block(heap, group->children[pos], info))
|
||||
{
|
||||
group->item_count--;
|
||||
block_map_parent_group_combine_child(heap, group, pos);
|
||||
block_map_parent_group_update_bounds(group);
|
||||
block_map_cluster_parent_group_combine_child(heap, group, pos);
|
||||
block_map_cluster_parent_group_update_bounds(group);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void block_map_parent_group_remove_groups(block_map_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
void block_map_cluster_parent_group_remove_groups(block_map_cluster_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
{
|
||||
parent_group_remove_groups((parent_group_t*)group, at, count);
|
||||
block_map_parent_group_update_bounds(group);
|
||||
cluster_parent_group_remove_groups((cluster_parent_group_t*)group, at, count);
|
||||
block_map_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
bool block_map_parent_group_shift_children(block_map_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
bool block_map_cluster_parent_group_shift_children(block_map_cluster_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
{
|
||||
int16_t space=parent_group_get_nearest_space((parent_group_t*)group, at);
|
||||
int16_t space=cluster_parent_group_get_nearest_space((cluster_parent_group_t*)group, at);
|
||||
if(space<0)
|
||||
return false;
|
||||
if(count>1&&space>at)
|
||||
at++;
|
||||
block_map_parent_group_move_empty_slot(group, space, at);
|
||||
block_map_cluster_parent_group_move_empty_slot(group, space, at);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool block_map_parent_group_split_child(heap_handle_t heap, block_map_parent_group_t* group, uint16_t at)
|
||||
bool block_map_cluster_parent_group_split_child(heap_handle_t heap, block_map_cluster_parent_group_t* group, uint16_t at)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
if(child_count==CLUSTER_GROUP_SIZE)
|
||||
|
|
@ -1040,7 +1040,7 @@ block_map_group_t* child=NULL;
|
|||
uint16_t level=cluster_group_get_level((cluster_group_t*)group);
|
||||
if(level>1)
|
||||
{
|
||||
child=(block_map_group_t*)block_map_parent_group_create(heap, level-1);
|
||||
child=(block_map_group_t*)block_map_cluster_parent_group_create(heap, level-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1052,11 +1052,11 @@ for(uint16_t u=child_count; u>at+1; u--)
|
|||
group->children[u]=group->children[u-1];
|
||||
group->children[at+1]=child;
|
||||
cluster_group_set_child_count((cluster_group_t*)group, child_count+1);
|
||||
block_map_parent_group_move_children(group, at, at+1, 1);
|
||||
block_map_cluster_parent_group_move_children(group, at, at+1, 1);
|
||||
return true;
|
||||
}
|
||||
|
||||
void block_map_parent_group_update_bounds(block_map_parent_group_t* group)
|
||||
void block_map_cluster_parent_group_update_bounds(block_map_cluster_parent_group_t* group)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
if(child_count==0)
|
||||
|
|
@ -1120,8 +1120,8 @@ if(level==0)
|
|||
return false;
|
||||
if(child_count>1)
|
||||
return false;
|
||||
block_map_parent_group_t* parent_group=(block_map_parent_group_t*)root;
|
||||
map->root=parent_group->children[0];
|
||||
block_map_cluster_parent_group_t* cluster_parent_group=(block_map_cluster_parent_group_t*)root;
|
||||
map->root=cluster_parent_group->children[0];
|
||||
heap_free_to_cache(heap, root);
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1140,7 +1140,7 @@ return false;
|
|||
|
||||
bool block_map_lift_root(heap_handle_t heap, block_map_t* map)
|
||||
{
|
||||
block_map_parent_group_t* root=block_map_parent_group_create_with_child(heap, map->root);
|
||||
block_map_cluster_parent_group_t* root=block_map_cluster_parent_group_create_with_child(heap, map->root);
|
||||
if(!root)
|
||||
return false;
|
||||
map->root=(block_map_group_t*)root;
|
||||
|
|
@ -1164,14 +1164,14 @@ size_t offset_index_group_get_first_offset(offset_index_group_t* group)
|
|||
{
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return offset_index_item_group_get_first_offset((offset_index_item_group_t*)group);
|
||||
return ((offset_index_parent_group_t*)group)->first_offset;
|
||||
return ((offset_index_cluster_parent_group_t*)group)->first_offset;
|
||||
}
|
||||
|
||||
size_t offset_index_group_get_last_offset(offset_index_group_t* group)
|
||||
{
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return offset_index_item_group_get_last_offset((offset_index_item_group_t*)group);
|
||||
return ((offset_index_parent_group_t*)group)->last_offset;
|
||||
return ((offset_index_cluster_parent_group_t*)group)->last_offset;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1187,7 +1187,7 @@ if(cluster_group_get_level(group)==0)
|
|||
}
|
||||
else
|
||||
{
|
||||
added=offset_index_parent_group_add_offset(heap, (offset_index_parent_group_t*)group, offset, again);
|
||||
added=offset_index_cluster_parent_group_add_offset(heap, (offset_index_cluster_parent_group_t*)group, offset, again);
|
||||
}
|
||||
cluster_group_set_locked((cluster_group_t*)group, false);
|
||||
return added;
|
||||
|
|
@ -1201,7 +1201,7 @@ if(cluster_group_get_level(group)==0)
|
|||
}
|
||||
else
|
||||
{
|
||||
offset_index_parent_group_remove_offset(heap, (offset_index_parent_group_t*)group, offset);
|
||||
offset_index_cluster_parent_group_remove_offset(heap, (offset_index_cluster_parent_group_t*)group, offset);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -1210,7 +1210,7 @@ size_t offset_index_group_remove_offset_at(heap_handle_t heap, offset_index_grou
|
|||
bool passive=cluster_group_is_locked((cluster_group_t*)group);
|
||||
if(cluster_group_get_level(group)==0)
|
||||
return offset_index_item_group_remove_offset_at((offset_index_item_group_t*)group, at, passive);
|
||||
return offset_index_parent_group_remove_offset_at(heap, (offset_index_parent_group_t*)group, at, passive);
|
||||
return offset_index_cluster_parent_group_remove_offset_at(heap, (offset_index_cluster_parent_group_t*)group, at, passive);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -1344,9 +1344,9 @@ cluster_group_set_child_count((cluster_group_t*)group, child_count-count);
|
|||
|
||||
// Con-/Destructors
|
||||
|
||||
offset_index_parent_group_t* offset_index_parent_group_create(heap_handle_t heap, uint16_t level)
|
||||
offset_index_cluster_parent_group_t* offset_index_cluster_parent_group_create(heap_handle_t heap, uint16_t level)
|
||||
{
|
||||
offset_index_parent_group_t* group=(offset_index_parent_group_t*)heap_alloc_internal(heap, sizeof(offset_index_parent_group_t));
|
||||
offset_index_cluster_parent_group_t* group=(offset_index_cluster_parent_group_t*)heap_alloc_internal(heap, sizeof(offset_index_cluster_parent_group_t));
|
||||
if(group==NULL)
|
||||
return NULL;
|
||||
cluster_group_init((cluster_group_t*)group, level, 0);
|
||||
|
|
@ -1356,9 +1356,9 @@ group->item_count=0;
|
|||
return group;
|
||||
}
|
||||
|
||||
offset_index_parent_group_t* offset_index_parent_group_create_with_child(heap_handle_t heap, offset_index_group_t* child)
|
||||
offset_index_cluster_parent_group_t* offset_index_cluster_parent_group_create_with_child(heap_handle_t heap, offset_index_group_t* child)
|
||||
{
|
||||
offset_index_parent_group_t* group=(offset_index_parent_group_t*)heap_alloc_internal(heap, sizeof(offset_index_parent_group_t));
|
||||
offset_index_cluster_parent_group_t* group=(offset_index_cluster_parent_group_t*)heap_alloc_internal(heap, sizeof(offset_index_cluster_parent_group_t));
|
||||
if(group==NULL)
|
||||
return NULL;
|
||||
uint16_t child_level=cluster_group_get_level(child);
|
||||
|
|
@ -1373,7 +1373,7 @@ return group;
|
|||
|
||||
// Access
|
||||
|
||||
uint16_t offset_index_parent_group_get_item_pos(offset_index_parent_group_t* group, size_t offset, uint16_t* pos_ptr, bool must_exist)
|
||||
uint16_t offset_index_cluster_parent_group_get_item_pos(offset_index_cluster_parent_group_t* group, size_t offset, uint16_t* pos_ptr, bool must_exist)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
uint16_t pos=0;
|
||||
|
|
@ -1407,22 +1407,22 @@ return 2;
|
|||
|
||||
// Modification
|
||||
|
||||
bool offset_index_parent_group_add_offset(heap_handle_t heap, offset_index_parent_group_t* group, size_t offset, bool again)
|
||||
bool offset_index_cluster_parent_group_add_offset(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t offset, bool again)
|
||||
{
|
||||
if(!offset_index_parent_group_add_offset_internal(heap, group, offset, again))
|
||||
if(!offset_index_cluster_parent_group_add_offset_internal(heap, group, offset, again))
|
||||
return false;
|
||||
group->item_count++;
|
||||
offset_index_parent_group_update_bounds(group);
|
||||
offset_index_cluster_parent_group_update_bounds(group);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool offset_index_parent_group_add_offset_internal(heap_handle_t heap, offset_index_parent_group_t* group, size_t offset, bool again)
|
||||
bool offset_index_cluster_parent_group_add_offset_internal(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t offset, bool again)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
if(!child_count)
|
||||
return false;
|
||||
uint16_t pos=0;
|
||||
uint16_t count=offset_index_parent_group_get_item_pos(group, offset, &pos, false);
|
||||
uint16_t count=offset_index_cluster_parent_group_get_item_pos(group, offset, &pos, false);
|
||||
if(!again)
|
||||
{
|
||||
for(uint16_t u=0; u<count; u++)
|
||||
|
|
@ -1430,9 +1430,9 @@ if(!again)
|
|||
if(offset_index_group_add_offset(heap, group->children[pos+u], offset, false))
|
||||
return true;
|
||||
}
|
||||
if(offset_index_parent_group_shift_children(group, pos, count))
|
||||
if(offset_index_cluster_parent_group_shift_children(group, pos, count))
|
||||
{
|
||||
count=offset_index_parent_group_get_item_pos(group, offset, &pos, false);
|
||||
count=offset_index_cluster_parent_group_get_item_pos(group, offset, &pos, false);
|
||||
for(uint16_t u=0; u<count; u++)
|
||||
{
|
||||
if(offset_index_group_add_offset(heap, group->children[pos+u], offset, false))
|
||||
|
|
@ -1440,9 +1440,9 @@ if(!again)
|
|||
}
|
||||
}
|
||||
}
|
||||
if(!offset_index_parent_group_split_child(heap, group, pos))
|
||||
if(!offset_index_cluster_parent_group_split_child(heap, group, pos))
|
||||
return false;
|
||||
count=offset_index_parent_group_get_item_pos(group, offset, &pos, false);
|
||||
count=offset_index_cluster_parent_group_get_item_pos(group, offset, &pos, false);
|
||||
for(uint16_t u=0; u<count; u++)
|
||||
{
|
||||
if(offset_index_group_add_offset(heap, group->children[pos+u], offset, true))
|
||||
|
|
@ -1451,18 +1451,18 @@ for(uint16_t u=0; u<count; u++)
|
|||
return false;
|
||||
}
|
||||
|
||||
void offset_index_parent_group_append_groups(offset_index_parent_group_t* group, offset_index_group_t* const* append, uint16_t count)
|
||||
void offset_index_cluster_parent_group_append_groups(offset_index_cluster_parent_group_t* group, offset_index_group_t* const* append, uint16_t count)
|
||||
{
|
||||
parent_group_append_groups((parent_group_t*)group, (cluster_group_t* const*)append, count);
|
||||
offset_index_parent_group_update_bounds(group);
|
||||
cluster_parent_group_append_groups((cluster_parent_group_t*)group, (cluster_group_t* const*)append, count);
|
||||
offset_index_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
bool offset_index_parent_group_combine_child(heap_handle_t heap, offset_index_parent_group_t* group, uint16_t at)
|
||||
bool offset_index_cluster_parent_group_combine_child(heap_handle_t heap, offset_index_cluster_parent_group_t* group, uint16_t at)
|
||||
{
|
||||
uint16_t count=cluster_group_get_child_count((cluster_group_t*)group->children[at]);
|
||||
if(count==0)
|
||||
{
|
||||
parent_group_remove_group(heap, (parent_group_t*)group, at);
|
||||
cluster_parent_group_remove_group(heap, (cluster_parent_group_t*)group, at);
|
||||
return true;
|
||||
}
|
||||
if(at>0)
|
||||
|
|
@ -1470,8 +1470,8 @@ if(at>0)
|
|||
uint16_t before=cluster_group_get_child_count((cluster_group_t*)group->children[at-1]);
|
||||
if(count+before<=CLUSTER_GROUP_SIZE)
|
||||
{
|
||||
offset_index_parent_group_move_children(group, at, at-1, count);
|
||||
parent_group_remove_group(heap, (parent_group_t*)group, at);
|
||||
offset_index_cluster_parent_group_move_children(group, at, at-1, count);
|
||||
cluster_parent_group_remove_group(heap, (cluster_parent_group_t*)group, at);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
|
@ -1481,20 +1481,20 @@ if(at+1<child_count)
|
|||
uint16_t after=cluster_group_get_child_count((cluster_group_t*)group->children[at+1]);
|
||||
if(count+after<=CLUSTER_GROUP_SIZE)
|
||||
{
|
||||
offset_index_parent_group_move_children(group, at+1, at, after);
|
||||
parent_group_remove_group(heap, (parent_group_t*)group, at+1);
|
||||
offset_index_cluster_parent_group_move_children(group, at+1, at, after);
|
||||
cluster_parent_group_remove_group(heap, (cluster_parent_group_t*)group, at+1);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void offset_index_parent_group_combine_children(heap_handle_t heap, offset_index_parent_group_t* group)
|
||||
void offset_index_cluster_parent_group_combine_children(heap_handle_t heap, offset_index_cluster_parent_group_t* group)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
for(uint16_t pos=0; pos<child_count; )
|
||||
{
|
||||
if(offset_index_parent_group_combine_child(heap, group, pos))
|
||||
if(offset_index_cluster_parent_group_combine_child(heap, group, pos))
|
||||
{
|
||||
child_count--;
|
||||
}
|
||||
|
|
@ -1505,29 +1505,29 @@ for(uint16_t pos=0; pos<child_count; )
|
|||
}
|
||||
}
|
||||
|
||||
void offset_index_parent_group_insert_groups(offset_index_parent_group_t* group, uint16_t at, offset_index_group_t* const* insert, uint16_t count)
|
||||
void offset_index_cluster_parent_group_insert_groups(offset_index_cluster_parent_group_t* group, uint16_t at, offset_index_group_t* const* insert, uint16_t count)
|
||||
{
|
||||
parent_group_insert_groups((parent_group_t*)group, at, (cluster_group_t* const*)insert, count);
|
||||
offset_index_parent_group_update_bounds(group);
|
||||
cluster_parent_group_insert_groups((cluster_parent_group_t*)group, at, (cluster_group_t* const*)insert, count);
|
||||
offset_index_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
void offset_index_parent_group_move_children(offset_index_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count)
|
||||
void offset_index_cluster_parent_group_move_children(offset_index_cluster_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count)
|
||||
{
|
||||
uint16_t level=cluster_group_get_level((cluster_group_t*)group);
|
||||
if(level>1)
|
||||
{
|
||||
offset_index_parent_group_t* src=(offset_index_parent_group_t*)group->children[from];
|
||||
offset_index_parent_group_t* dst=(offset_index_parent_group_t*)group->children[to];
|
||||
offset_index_cluster_parent_group_t* src=(offset_index_cluster_parent_group_t*)group->children[from];
|
||||
offset_index_cluster_parent_group_t* dst=(offset_index_cluster_parent_group_t*)group->children[to];
|
||||
if(from>to)
|
||||
{
|
||||
offset_index_parent_group_append_groups(dst, src->children, count);
|
||||
offset_index_parent_group_remove_groups(src, 0, count);
|
||||
offset_index_cluster_parent_group_append_groups(dst, src->children, count);
|
||||
offset_index_cluster_parent_group_remove_groups(src, 0, count);
|
||||
}
|
||||
else
|
||||
{
|
||||
uint16_t src_count=cluster_group_get_child_count((cluster_group_t*)src);
|
||||
offset_index_parent_group_insert_groups(dst, 0, &src->children[src_count-count], count);
|
||||
offset_index_parent_group_remove_groups(src, src_count-count, count);
|
||||
offset_index_cluster_parent_group_insert_groups(dst, 0, &src->children[src_count-count], count);
|
||||
offset_index_cluster_parent_group_remove_groups(src, src_count-count, count);
|
||||
}
|
||||
}
|
||||
else
|
||||
|
|
@ -1548,40 +1548,40 @@ else
|
|||
}
|
||||
}
|
||||
|
||||
void offset_index_parent_group_move_empty_slot(offset_index_parent_group_t* group, uint16_t from, uint16_t to)
|
||||
void offset_index_cluster_parent_group_move_empty_slot(offset_index_cluster_parent_group_t* group, uint16_t from, uint16_t to)
|
||||
{
|
||||
if(from<to)
|
||||
{
|
||||
for(uint16_t u=from; u<to; u++)
|
||||
offset_index_parent_group_move_children(group, u+1, u, 1);
|
||||
offset_index_cluster_parent_group_move_children(group, u+1, u, 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
for(uint16_t u=from; u>to; u--)
|
||||
offset_index_parent_group_move_children(group, u-1, u, 1);
|
||||
offset_index_cluster_parent_group_move_children(group, u-1, u, 1);
|
||||
}
|
||||
}
|
||||
|
||||
void offset_index_parent_group_remove_groups(offset_index_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
void offset_index_cluster_parent_group_remove_groups(offset_index_cluster_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
{
|
||||
parent_group_remove_groups((parent_group_t*)group, at, count);
|
||||
offset_index_parent_group_update_bounds(group);
|
||||
cluster_parent_group_remove_groups((cluster_parent_group_t*)group, at, count);
|
||||
offset_index_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
void offset_index_parent_group_remove_offset(heap_handle_t heap, offset_index_parent_group_t* group, size_t offset)
|
||||
void offset_index_cluster_parent_group_remove_offset(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t offset)
|
||||
{
|
||||
uint16_t pos=0;
|
||||
uint16_t count=offset_index_parent_group_get_item_pos(group, offset, &pos, true);
|
||||
uint16_t count=offset_index_cluster_parent_group_get_item_pos(group, offset, &pos, true);
|
||||
configASSERT(count==1);
|
||||
offset_index_group_remove_offset(heap, group->children[pos], offset);
|
||||
offset_index_parent_group_combine_child(heap, group, pos);
|
||||
offset_index_cluster_parent_group_combine_child(heap, group, pos);
|
||||
group->item_count--;
|
||||
offset_index_parent_group_update_bounds(group);
|
||||
offset_index_cluster_parent_group_update_bounds(group);
|
||||
}
|
||||
|
||||
size_t offset_index_parent_group_remove_offset_at(heap_handle_t heap, offset_index_parent_group_t* group, size_t at, bool passive)
|
||||
size_t offset_index_cluster_parent_group_remove_offset_at(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t at, bool passive)
|
||||
{
|
||||
uint16_t pos=parent_group_get_group((parent_group_t*)group, &at);
|
||||
uint16_t pos=cluster_parent_group_get_group((cluster_parent_group_t*)group, &at);
|
||||
configASSERT(pos<CLUSTER_GROUP_SIZE);
|
||||
size_t offset=offset_index_group_remove_offset_at(heap, group->children[pos], at);
|
||||
if(passive)
|
||||
|
|
@ -1592,31 +1592,31 @@ else
|
|||
{
|
||||
if(cluster_group_is_dirty((cluster_group_t*)group))
|
||||
{
|
||||
offset_index_parent_group_combine_children(heap, group);
|
||||
offset_index_cluster_parent_group_combine_children(heap, group);
|
||||
cluster_group_set_dirty((cluster_group_t*)group, false);
|
||||
}
|
||||
else
|
||||
{
|
||||
offset_index_parent_group_combine_child(heap, group, pos);
|
||||
offset_index_cluster_parent_group_combine_child(heap, group, pos);
|
||||
}
|
||||
}
|
||||
group->item_count--;
|
||||
offset_index_parent_group_update_bounds(group);
|
||||
offset_index_cluster_parent_group_update_bounds(group);
|
||||
return offset;
|
||||
}
|
||||
|
||||
bool offset_index_parent_group_shift_children(offset_index_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
bool offset_index_cluster_parent_group_shift_children(offset_index_cluster_parent_group_t* group, uint16_t at, uint16_t count)
|
||||
{
|
||||
int16_t space=parent_group_get_nearest_space((parent_group_t*)group, at);
|
||||
int16_t space=cluster_parent_group_get_nearest_space((cluster_parent_group_t*)group, at);
|
||||
if(space<0)
|
||||
return false;
|
||||
if(count>1&&space>at)
|
||||
at++;
|
||||
offset_index_parent_group_move_empty_slot(group, space, at);
|
||||
offset_index_cluster_parent_group_move_empty_slot(group, space, at);
|
||||
return true;
|
||||
}
|
||||
|
||||
bool offset_index_parent_group_split_child(heap_handle_t heap, offset_index_parent_group_t* group, uint16_t at)
|
||||
bool offset_index_cluster_parent_group_split_child(heap_handle_t heap, offset_index_cluster_parent_group_t* group, uint16_t at)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
if(child_count==CLUSTER_GROUP_SIZE)
|
||||
|
|
@ -1625,7 +1625,7 @@ offset_index_group_t* child=NULL;
|
|||
uint16_t level=cluster_group_get_level((cluster_group_t*)group);
|
||||
if(level>1)
|
||||
{
|
||||
child=(offset_index_group_t*)offset_index_parent_group_create(heap, level-1);
|
||||
child=(offset_index_group_t*)offset_index_cluster_parent_group_create(heap, level-1);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -1637,11 +1637,11 @@ for(uint16_t u=child_count; u>at+1; u--)
|
|||
group->children[u]=group->children[u-1];
|
||||
group->children[at+1]=child;
|
||||
cluster_group_set_child_count((cluster_group_t*)group, child_count+1);
|
||||
offset_index_parent_group_move_children(group, at, at+1, 1);
|
||||
offset_index_cluster_parent_group_move_children(group, at, at+1, 1);
|
||||
return true;
|
||||
}
|
||||
|
||||
void offset_index_parent_group_update_bounds(offset_index_parent_group_t* group)
|
||||
void offset_index_cluster_parent_group_update_bounds(offset_index_cluster_parent_group_t* group)
|
||||
{
|
||||
uint16_t child_count=cluster_group_get_child_count((cluster_group_t*)group);
|
||||
if(child_count==0)
|
||||
|
|
@ -1712,14 +1712,14 @@ if(level==0)
|
|||
}
|
||||
if(child_count>1)
|
||||
return;
|
||||
offset_index_parent_group_t* parent_group=(offset_index_parent_group_t*)root;
|
||||
index->root=parent_group->children[0];
|
||||
offset_index_cluster_parent_group_t* cluster_parent_group=(offset_index_cluster_parent_group_t*)root;
|
||||
index->root=cluster_parent_group->children[0];
|
||||
heap_free_to_cache(heap, root);
|
||||
}
|
||||
|
||||
bool offset_index_lift_root(heap_handle_t heap, offset_index_t* index)
|
||||
{
|
||||
offset_index_parent_group_t* root=offset_index_parent_group_create_with_child(heap, index->root);
|
||||
offset_index_cluster_parent_group_t* root=offset_index_cluster_parent_group_create_with_child(heap, index->root);
|
||||
if(!root)
|
||||
return false;
|
||||
index->root=(offset_index_group_t*)root;
|
||||
|
|
|
|||
|
|
@ -261,9 +261,9 @@ group->value=set.value;
|
|||
}
|
||||
|
||||
|
||||
//==============
|
||||
// Parent-Group
|
||||
//==============
|
||||
//======================
|
||||
// Cluster-Parent-Group
|
||||
//======================
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
@ -272,19 +272,19 @@ size_t item_count;
|
|||
size_t first;
|
||||
size_t last;
|
||||
cluster_group_t* children[CLUSTER_GROUP_SIZE];
|
||||
}parent_group_t;
|
||||
}cluster_parent_group_t;
|
||||
|
||||
|
||||
// Access
|
||||
uint16_t parent_group_get_group(parent_group_t* group, size_t* at);
|
||||
int16_t parent_group_get_nearest_space(parent_group_t* group, int16_t pos);
|
||||
uint16_t cluster_parent_group_get_group(cluster_parent_group_t* group, size_t* at);
|
||||
int16_t cluster_parent_group_get_nearest_space(cluster_parent_group_t* group, int16_t pos);
|
||||
|
||||
|
||||
// Modification
|
||||
void parent_group_append_groups(parent_group_t* group, cluster_group_t* const* append, uint16_t count);
|
||||
void parent_group_insert_groups(parent_group_t* group, uint16_t at, cluster_group_t* const* insert, uint16_t count);
|
||||
void parent_group_remove_group(heap_handle_t heap, parent_group_t* group, uint16_t at);
|
||||
void parent_group_remove_groups(parent_group_t* group, uint16_t at, uint16_t count);
|
||||
void cluster_parent_group_append_groups(cluster_parent_group_t* group, cluster_group_t* const* append, uint16_t count);
|
||||
void cluster_parent_group_insert_groups(cluster_parent_group_t* group, uint16_t at, cluster_group_t* const* insert, uint16_t count);
|
||||
void cluster_parent_group_remove_group(heap_handle_t heap, cluster_parent_group_t* group, uint16_t at);
|
||||
void cluster_parent_group_remove_groups(cluster_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
|
||||
|
||||
//================
|
||||
|
|
@ -367,31 +367,31 @@ size_t item_count;
|
|||
size_t first_size;
|
||||
size_t last_size;
|
||||
block_map_group_t* children[CLUSTER_GROUP_SIZE];
|
||||
}block_map_parent_group_t;
|
||||
}block_map_cluster_parent_group_t;
|
||||
|
||||
// Con-/Destructors
|
||||
block_map_parent_group_t* block_map_parent_group_create(heap_handle_t heap, uint16_t level);
|
||||
block_map_parent_group_t* block_map_parent_group_create_with_child(heap_handle_t heap, block_map_group_t* child);
|
||||
block_map_cluster_parent_group_t* block_map_cluster_parent_group_create(heap_handle_t heap, uint16_t level);
|
||||
block_map_cluster_parent_group_t* block_map_cluster_parent_group_create_with_child(heap_handle_t heap, block_map_group_t* child);
|
||||
|
||||
// Access
|
||||
block_map_item_t* block_map_parent_group_get_item(block_map_parent_group_t* group, size_t size);
|
||||
uint16_t block_map_parent_group_get_item_pos(block_map_parent_group_t* group, size_t size, uint16_t* pos_ptr, bool must_exist);
|
||||
block_map_item_t* block_map_cluster_parent_group_get_item(block_map_cluster_parent_group_t* group, size_t size);
|
||||
uint16_t block_map_cluster_parent_group_get_item_pos(block_map_cluster_parent_group_t* group, size_t size, uint16_t* pos_ptr, bool must_exist);
|
||||
|
||||
// Modification
|
||||
bool block_map_parent_group_add_block(heap_handle_t heap, block_map_parent_group_t* group, heap_block_info_t const* info, bool again);
|
||||
bool block_map_parent_group_add_block_internal(heap_handle_t heap, block_map_parent_group_t* group, heap_block_info_t const* info, bool again);
|
||||
void block_map_parent_group_append_groups(block_map_parent_group_t* group, block_map_group_t* const* append, uint16_t count);
|
||||
bool block_map_parent_group_combine_child(heap_handle_t heap, block_map_parent_group_t* group, uint16_t pos);
|
||||
void block_map_parent_group_combine_children(heap_handle_t heap, block_map_parent_group_t* group);
|
||||
bool block_map_parent_group_get_block(heap_handle_t heap, block_map_parent_group_t* group, size_t min_size, heap_block_info_t* info, bool passive);
|
||||
void block_map_parent_group_insert_groups(block_map_parent_group_t* group, uint16_t at, block_map_group_t* const* insert, uint16_t count);
|
||||
void block_map_parent_group_move_children(block_map_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count);
|
||||
void block_map_parent_group_move_empty_slot(block_map_parent_group_t* group, uint16_t from, uint16_t to);
|
||||
bool block_map_parent_group_remove_block(heap_handle_t heap, block_map_parent_group_t* group, heap_block_info_t const* info);
|
||||
void block_map_parent_group_remove_groups(block_map_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
bool block_map_parent_group_shift_children(block_map_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
bool block_map_parent_group_split_child(heap_handle_t heap, block_map_parent_group_t* group, uint16_t at);
|
||||
void block_map_parent_group_update_bounds(block_map_parent_group_t* group);
|
||||
bool block_map_cluster_parent_group_add_block(heap_handle_t heap, block_map_cluster_parent_group_t* group, heap_block_info_t const* info, bool again);
|
||||
bool block_map_cluster_parent_group_add_block_internal(heap_handle_t heap, block_map_cluster_parent_group_t* group, heap_block_info_t const* info, bool again);
|
||||
void block_map_cluster_parent_group_append_groups(block_map_cluster_parent_group_t* group, block_map_group_t* const* append, uint16_t count);
|
||||
bool block_map_cluster_parent_group_combine_child(heap_handle_t heap, block_map_cluster_parent_group_t* group, uint16_t pos);
|
||||
void block_map_cluster_parent_group_combine_children(heap_handle_t heap, block_map_cluster_parent_group_t* group);
|
||||
bool block_map_cluster_parent_group_get_block(heap_handle_t heap, block_map_cluster_parent_group_t* group, size_t min_size, heap_block_info_t* info, bool passive);
|
||||
void block_map_cluster_parent_group_insert_groups(block_map_cluster_parent_group_t* group, uint16_t at, block_map_group_t* const* insert, uint16_t count);
|
||||
void block_map_cluster_parent_group_move_children(block_map_cluster_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count);
|
||||
void block_map_cluster_parent_group_move_empty_slot(block_map_cluster_parent_group_t* group, uint16_t from, uint16_t to);
|
||||
bool block_map_cluster_parent_group_remove_block(heap_handle_t heap, block_map_cluster_parent_group_t* group, heap_block_info_t const* info);
|
||||
void block_map_cluster_parent_group_remove_groups(block_map_cluster_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
bool block_map_cluster_parent_group_shift_children(block_map_cluster_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
bool block_map_cluster_parent_group_split_child(heap_handle_t heap, block_map_cluster_parent_group_t* group, uint16_t at);
|
||||
void block_map_cluster_parent_group_update_bounds(block_map_cluster_parent_group_t* group);
|
||||
|
||||
|
||||
//===========
|
||||
|
|
@ -487,31 +487,31 @@ size_t item_count;
|
|||
size_t first_offset;
|
||||
size_t last_offset;
|
||||
offset_index_group_t* children[CLUSTER_GROUP_SIZE];
|
||||
}offset_index_parent_group_t;
|
||||
}offset_index_cluster_parent_group_t;
|
||||
|
||||
|
||||
// Con-/Destructors
|
||||
offset_index_parent_group_t* offset_index_parent_group_create(heap_handle_t heap, uint16_t level);
|
||||
offset_index_parent_group_t* offset_index_parent_group_create_with_child(heap_handle_t heap, offset_index_group_t* child);
|
||||
offset_index_cluster_parent_group_t* offset_index_cluster_parent_group_create(heap_handle_t heap, uint16_t level);
|
||||
offset_index_cluster_parent_group_t* offset_index_cluster_parent_group_create_with_child(heap_handle_t heap, offset_index_group_t* child);
|
||||
|
||||
// Access
|
||||
uint16_t offset_index_parent_group_get_item_pos(offset_index_parent_group_t* group, size_t offset, uint16_t* pos_ptr, bool must_exist);
|
||||
uint16_t offset_index_cluster_parent_group_get_item_pos(offset_index_cluster_parent_group_t* group, size_t offset, uint16_t* pos_ptr, bool must_exist);
|
||||
|
||||
// Modification
|
||||
bool offset_index_parent_group_add_offset(heap_handle_t heap, offset_index_parent_group_t* group, size_t offset, bool again);
|
||||
bool offset_index_parent_group_add_offset_internal(heap_handle_t heap, offset_index_parent_group_t* group, size_t offset, bool again);
|
||||
void offset_index_parent_group_append_groups(offset_index_parent_group_t* group, offset_index_group_t* const* append, uint16_t count);
|
||||
bool offset_index_parent_group_combine_child(heap_handle_t heap, offset_index_parent_group_t* group, uint16_t at);
|
||||
void offset_index_parent_group_combine_children(heap_handle_t heap, offset_index_parent_group_t* group);
|
||||
void offset_index_parent_group_insert_groups(offset_index_parent_group_t* group, uint16_t at, offset_index_group_t* const* insert, uint16_t count);
|
||||
void offset_index_parent_group_move_children(offset_index_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count);
|
||||
void offset_index_parent_group_move_empty_slot(offset_index_parent_group_t* group, uint16_t from, uint16_t to);
|
||||
void offset_index_parent_group_remove_groups(offset_index_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
void offset_index_parent_group_remove_offset(heap_handle_t heap, offset_index_parent_group_t* group, size_t offset);
|
||||
size_t offset_index_parent_group_remove_offset_at(heap_handle_t heap, offset_index_parent_group_t* group, size_t at, bool passive);
|
||||
bool offset_index_parent_group_shift_children(offset_index_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
bool offset_index_parent_group_split_child(heap_handle_t heap, offset_index_parent_group_t* group, uint16_t at);
|
||||
void offset_index_parent_group_update_bounds(offset_index_parent_group_t* group);
|
||||
bool offset_index_cluster_parent_group_add_offset(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t offset, bool again);
|
||||
bool offset_index_cluster_parent_group_add_offset_internal(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t offset, bool again);
|
||||
void offset_index_cluster_parent_group_append_groups(offset_index_cluster_parent_group_t* group, offset_index_group_t* const* append, uint16_t count);
|
||||
bool offset_index_cluster_parent_group_combine_child(heap_handle_t heap, offset_index_cluster_parent_group_t* group, uint16_t at);
|
||||
void offset_index_cluster_parent_group_combine_children(heap_handle_t heap, offset_index_cluster_parent_group_t* group);
|
||||
void offset_index_cluster_parent_group_insert_groups(offset_index_cluster_parent_group_t* group, uint16_t at, offset_index_group_t* const* insert, uint16_t count);
|
||||
void offset_index_cluster_parent_group_move_children(offset_index_cluster_parent_group_t* group, uint16_t from, uint16_t to, uint16_t count);
|
||||
void offset_index_cluster_parent_group_move_empty_slot(offset_index_cluster_parent_group_t* group, uint16_t from, uint16_t to);
|
||||
void offset_index_cluster_parent_group_remove_groups(offset_index_cluster_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
void offset_index_cluster_parent_group_remove_offset(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t offset);
|
||||
size_t offset_index_cluster_parent_group_remove_offset_at(heap_handle_t heap, offset_index_cluster_parent_group_t* group, size_t at, bool passive);
|
||||
bool offset_index_cluster_parent_group_shift_children(offset_index_cluster_parent_group_t* group, uint16_t at, uint16_t count);
|
||||
bool offset_index_cluster_parent_group_split_child(heap_handle_t heap, offset_index_cluster_parent_group_t* group, uint16_t at);
|
||||
void offset_index_cluster_parent_group_update_bounds(offset_index_cluster_parent_group_t* group);
|
||||
|
||||
|
||||
//==============
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue