zzy/scc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(core): 添加字符串长度计算函数并优化数据结构定义

Browse Source 
- 在 `core_mem.h` 中新增 `smcc_strlen` 函数，用于计算字符串长度
- 调整 `VEC` 宏定义参数，移除冗余的 name 参数，增强结构体声明一致性
- 修改 `cstring_from_cstr` 返回值字段顺序，保持代码风格统一
- 在 `libcore.h` 中增加日志相关宏定义的保护判断，防止重复定义冲突
This commit is contained in:
zzy
2025-11-20 22:26:49 +08:00
parent d1fafa830d
commit f29fd92fdf
10 changed files with 2082 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
runtime/libutils/src/hashtable.c → runtime/libutils/src/hashmap.c
View File

@@ -1,12 +1,14 @@
#include <hashtable.h>
#include <hashmap.h>
#define INIT_HASH_TABLE_SIZE (32)
#ifndef SMCC_INIT_HASHMAP_SIZE
#define SMCC_INIT_HASHMAP_SIZE (32)
#endif
void init_hashtable(hash_table_t *ht) {
vector_init(ht->entries);
void hashmap_init(hashmap_t *ht) {
vec_init(ht->entries);
ht->count = 0;
ht->tombstone_count = 0;
// Assert(ht->key_cmp != NULL && ht->hash_func != NULL);
Assert(ht->key_cmp != NULL && ht->hash_func != NULL);
}
static int next_power_of_two(int n) {
@@ -19,17 +21,17 @@ static int next_power_of_two(int n) {
return n + 1;
}
static hash_entry_t *find_entry(hash_table_t *ht, const void *key, u32 hash) {
static hashmap_entry_t *find_entry(hashmap_t *ht, const void *key, u32 hash) {
if (ht->entries.cap == 0)
return NULL;
u32 index = hash & (ht->entries.cap - 1); // 容量是2的幂
u32 probe = 0;
hash_entry_t *tombstone = NULL;
hashmap_entry_t *tombstone = NULL;
while (1) {
hash_entry_t *entry = &vector_at(ht->entries, index);
hashmap_entry_t *entry = &vec_at(ht->entries, index);
if (entry->state == ENTRY_EMPTY) {
return tombstone ? tombstone : entry;
}
@@ -51,43 +53,43 @@ static hash_entry_t *find_entry(hash_table_t *ht, const void *key, u32 hash) {
return NULL;
}
static void adjust_capacity(hash_table_t *ht, int new_cap) {
static void adjust_capacity(hashmap_t *ht, int new_cap) {
new_cap = next_power_of_two(new_cap);
Assert(new_cap >= ht->entries.cap);
VECTOR_HEADER(old_entries, hash_entry_t);
VEC(hashmap_entry_t) old_entries;
old_entries.data = ht->entries.data;
old_entries.cap = ht->entries.cap;
// Not used size but for gdb python extention debug
ht->entries.size = new_cap;
ht->entries.cap = new_cap;
ht->entries.data = smcc_realloc(NULL, new_cap * sizeof(hash_entry_t));
smcc_memset(ht->entries.data, 0, new_cap * sizeof(hash_entry_t));
ht->entries.data = smcc_realloc(NULL, new_cap * sizeof(hashmap_entry_t));
smcc_memset(ht->entries.data, 0, new_cap * sizeof(hashmap_entry_t));
// rehash the all of the old data
for (usize i = 0; i < old_entries.cap; i++) {
hash_entry_t *entry = &vector_at(old_entries, i);
hashmap_entry_t *entry = &vec_at(old_entries, i);
if (entry->state == ENTRY_ACTIVE) {
hash_entry_t *dest = find_entry(ht, entry->key, entry->hash);
hashmap_entry_t *dest = find_entry(ht, entry->key, entry->hash);
*dest = *entry;
}
}
vector_free(old_entries);
vec_free(old_entries);
ht->tombstone_count = 0;
}
void *hashtable_set(hash_table_t *ht, const void *key, void *value) {
void *hashmap_set(hashmap_t *ht, const void *key, void *value) {
if (ht->count + ht->tombstone_count >= ht->entries.cap * 0.75) {
int new_cap = ht->entries.cap < INIT_HASH_TABLE_SIZE
? INIT_HASH_TABLE_SIZE
int new_cap = ht->entries.cap < SMCC_INIT_HASHMAP_SIZE
? SMCC_INIT_HASHMAP_SIZE
: ht->entries.cap * 2;
adjust_capacity(ht, new_cap);
}
u32 hash = ht->hash_func(key);
hash_entry_t *entry = find_entry(ht, key, hash);
hashmap_entry_t *entry = find_entry(ht, key, hash);
void *old_value = NULL;
if (entry->state == ENTRY_ACTIVE) {
@@ -105,21 +107,21 @@ void *hashtable_set(hash_table_t *ht, const void *key, void *value) {
return old_value;
}
void *hashtable_get(hash_table_t *ht, const void *key) {
void *hashmap_get(hashmap_t *ht, const void *key) {
if (ht->entries.cap == 0)
return NULL;
u32 hash = ht->hash_func(key);
hash_entry_t *entry = find_entry(ht, key, hash);
hashmap_entry_t *entry = find_entry(ht, key, hash);
return (entry && entry->state == ENTRY_ACTIVE) ? entry->value : NULL;
}
void *hashtable_del(hash_table_t *ht, const void *key) {
void *hashmap_del(hashmap_t *ht, const void *key) {
if (ht->entries.cap == 0)
return NULL;
u32 hash = ht->hash_func(key);
hash_entry_t *entry = find_entry(ht, key, hash);
hashmap_entry_t *entry = find_entry(ht, key, hash);
if (entry == NULL || entry->state != ENTRY_ACTIVE)
return NULL;
@@ -131,16 +133,15 @@ void *hashtable_del(hash_table_t *ht, const void *key) {
return value;
}
void hashtable_destory(hash_table_t *ht) {
vector_free(ht->entries);
void hashmap_drop(hashmap_t *ht) {
vec_free(ht->entries);
ht->count = 0;
ht->tombstone_count = 0;
}
void hashtable_foreach(hash_table_t *ht, hash_table_iter_func iter_func,
void *context) {
void hashmap_foreach(hashmap_t *ht, hashmap_iter_fn iter_func, void *context) {
for (usize i = 0; i < ht->entries.cap; i++) {
hash_entry_t *entry = &vector_at(ht->entries, i);
hashmap_entry_t *entry = &vec_at(ht->entries, i);
if (entry->state == ENTRY_ACTIVE) {
if (!iter_func(entry->key, entry->value, context)) {
break; // enable callback function terminal the iter

38
runtime/libutils/src/strpool.c
View File

@@ -1,47 +1,27 @@
#include "strpool.h"
u32 rt_strhash(const char *s) {
u32 hash = 2166136261u; // FNV-1a偏移基础值
while (*s) {
hash ^= *s++;
hash *= 16777619u;
}
return hash;
}
int rt_strcmp(const char *s1, const char *s2) {
while (*s1 && *s2 && *s1 == *s2) {
s1++;
s2++;
}
return *s1 - *s2;
}
void init_strpool(strpool_t *pool) {
pool->ht.hash_func = (u32 (*)(const void *))rt_strhash;
pool->ht.key_cmp = (int (*)(const void *, const void *))rt_strcmp;
init_hashtable(&pool->ht);
pool->ht.hash_func = (u32 (*)(const void *))smcc_strhash32;
pool->ht.key_cmp = (int (*)(const void *, const void *))smcc_strcmp;
hashmap_init(&pool->ht);
}
const char *strpool_intern(strpool_t *pool, const char *str) {
void *existing = hashtable_get(&pool->ht, str);
void *existing = hashmap_get(&pool->ht, str);
if (existing) {
return existing;
}
rt_size_t len = rt_strlen(str) + 1;
char *new_str = lalloc_alloc(&pool->stralloc, len);
usize len = smcc_strlen(str) + 1;
char *new_str = smcc_malloc(len);
if (!new_str) {
LOG_ERROR("strpool: Failed to allocate memory for string");
return NULL;
}
rt_memcpy(new_str, str, len);
smcc_memcpy(new_str, str, len);
hashtable_set(&pool->ht, new_str, new_str);
hashmap_set(&pool->ht, new_str, new_str);
return new_str;
}
void strpool_destroy(strpool_t *pool) {
hashtable_destory(&pool->ht);
lalloc_destroy(&pool->stralloc);
}
void strpool_destroy(strpool_t *pool) { hashmap_drop(&pool->ht); }