Misc #10278 » 0001-st.c-use-ccan-linked-list.patch
| include/ruby/st.h | ||
|---|---|---|
|
union {
|
||
|
struct {
|
||
|
struct st_table_entry **bins;
|
||
|
struct st_table_entry *head, *tail;
|
||
|
void *private_list_head[2];
|
||
|
} big;
|
||
|
struct {
|
||
|
struct st_packed_entry *entries;
|
||
| st.c | ||
|---|---|---|
|
#include <stdlib.h>
|
||
|
#endif
|
||
|
#include <string.h>
|
||
|
#include "ccan/list/list.h"
|
||
|
typedef struct st_table_entry st_table_entry;
|
||
| ... | ... | |
|
st_data_t key;
|
||
|
st_data_t record;
|
||
|
st_table_entry *next;
|
||
|
st_table_entry *fore, *back;
|
||
|
struct list_node olist;
|
||
|
};
|
||
|
typedef struct st_packed_entry {
|
||
| ... | ... | |
|
/* Shortcut */
|
||
|
#define bins as.big.bins
|
||
|
#define head as.big.head
|
||
|
#define tail as.big.tail
|
||
|
#define real_entries as.packed.real_entries
|
||
|
/* preparation for possible packing improvements */
|
||
| ... | ... | |
|
}
|
||
|
#endif
|
||
|
static inline struct list_head *
|
||
|
st_head(const st_table *tbl)
|
||
|
{
|
||
|
return (struct list_head *)&tbl->as.big.private_list_head;
|
||
|
}
|
||
|
st_table*
|
||
|
st_init_table_with_size(const struct st_hash_type *type, st_index_t size)
|
||
|
{
|
||
| ... | ... | |
|
tbl->entries_packed = size <= MAX_PACKED_HASH;
|
||
|
if (tbl->entries_packed) {
|
||
|
size = ST_DEFAULT_PACKED_TABLE_SIZE;
|
||
|
tbl->real_entries = 0;
|
||
|
}
|
||
|
else {
|
||
|
size = new_size(size); /* round up to power-of-two */
|
||
|
list_head_init(st_head(tbl));
|
||
|
}
|
||
|
tbl->num_bins = size;
|
||
|
tbl->bins = st_alloc_bins(size);
|
||
|
tbl->head = 0;
|
||
|
tbl->tail = 0;
|
||
|
return tbl;
|
||
|
}
|
||
| ... | ... | |
|
st_clear(st_table *table)
|
||
|
{
|
||
|
register st_table_entry *ptr, *next;
|
||
|
st_index_t i;
|
||
|
if (table->entries_packed) {
|
||
|
table->num_entries = 0;
|
||
| ... | ... | |
|
return;
|
||
|
}
|
||
|
for (i = 0; i < table->num_bins; i++) {
|
||
|
ptr = table->bins[i];
|
||
|
table->bins[i] = 0;
|
||
|
while (ptr != 0) {
|
||
|
next = ptr->next;
|
||
|
st_free_entry(ptr);
|
||
|
ptr = next;
|
||
|
}
|
||
|
list_for_each_safe(st_head(table), ptr, next, olist) {
|
||
|
/* list_del is not needed */
|
||
|
st_free_entry(ptr);
|
||
|
}
|
||
|
table->num_entries = 0;
|
||
|
table->head = 0;
|
||
|
table->tail = 0;
|
||
|
MEMZERO(table->bins, st_table_entry*, table->num_bins);
|
||
|
list_head_init(st_head(table));
|
||
|
}
|
||
|
void
|
||
| ... | ... | |
|
}
|
||
|
entry = new_entry(table, key, value, hash_val, bin_pos);
|
||
|
if (table->head != 0) {
|
||
|
entry->fore = 0;
|
||
|
(entry->back = table->tail)->fore = entry;
|
||
|
table->tail = entry;
|
||
|
}
|
||
|
else {
|
||
|
table->head = table->tail = entry;
|
||
|
entry->fore = entry->back = 0;
|
||
|
}
|
||
|
list_add_tail(st_head(table), &entry->olist);
|
||
|
table->num_entries++;
|
||
|
}
|
||
| ... | ... | |
|
{
|
||
|
st_index_t i;
|
||
|
st_packed_entry packed_bins[MAX_PACKED_HASH];
|
||
|
register st_table_entry *entry, *preventry = 0, **chain;
|
||
|
register st_table_entry *entry;
|
||
|
st_table tmp_table = *table;
|
||
|
MEMCPY(packed_bins, PACKED_BINS(table), st_packed_entry, MAX_PACKED_HASH);
|
||
| ... | ... | |
|
tmp_table.bins = st_realloc_bins(tmp_table.bins, ST_DEFAULT_INIT_TABLE_SIZE, tmp_table.num_bins);
|
||
|
tmp_table.num_bins = ST_DEFAULT_INIT_TABLE_SIZE;
|
||
|
#endif
|
||
|
/*
|
||
|
* order is important here, we need to keep the original table
|
||
|
* walkable during GC (GC may be triggered by new_entry call)
|
||
|
*/
|
||
|
i = 0;
|
||
|
chain = &tmp_table.head;
|
||
|
list_head_init(st_head(&tmp_table));
|
||
|
do {
|
||
|
st_data_t key = packed_bins[i].key;
|
||
|
st_data_t val = packed_bins[i].val;
|
||
|
st_index_t hash = packed_bins[i].hash;
|
||
|
entry = new_entry(&tmp_table, key, val, hash,
|
||
|
hash_pos(hash, ST_DEFAULT_INIT_TABLE_SIZE));
|
||
|
*chain = entry;
|
||
|
entry->back = preventry;
|
||
|
preventry = entry;
|
||
|
chain = &entry->fore;
|
||
|
list_add_tail(st_head(&tmp_table), &entry->olist);
|
||
|
} while (++i < MAX_PACKED_HASH);
|
||
|
*chain = NULL;
|
||
|
tmp_table.tail = entry;
|
||
|
*table = tmp_table;
|
||
|
list_head_init(st_head(table));
|
||
|
list_append_list(st_head(table), st_head(&tmp_table));
|
||
|
}
|
||
|
static void
|
||
| ... | ... | |
|
table->num_bins = new_num_bins;
|
||
|
table->bins = new_bins;
|
||
|
if ((ptr = table->head) != 0) {
|
||
|
do {
|
||
|
hash_val = hash_pos(ptr->hash, new_num_bins);
|
||
|
ptr->next = new_bins[hash_val];
|
||
|
new_bins[hash_val] = ptr;
|
||
|
} while ((ptr = ptr->fore) != 0);
|
||
|
list_for_each(st_head(table), ptr, olist) {
|
||
|
hash_val = hash_pos(ptr->hash, new_num_bins);
|
||
|
ptr->next = new_bins[hash_val];
|
||
|
new_bins[hash_val] = ptr;
|
||
|
}
|
||
|
}
|
||
| ... | ... | |
|
st_copy(st_table *old_table)
|
||
|
{
|
||
|
st_table *new_table;
|
||
|
st_table_entry *ptr, *entry, *prev, **tailp;
|
||
|
st_table_entry *ptr, *entry;
|
||
|
st_index_t num_bins = old_table->num_bins;
|
||
|
st_index_t hash_val;
|
||
|
new_table = st_alloc_table();
|
||
|
if (new_table == 0) {
|
||
| ... | ... | |
|
return new_table;
|
||
|
}
|
||
|
if ((ptr = old_table->head) != 0) {
|
||
|
prev = 0;
|
||
|
tailp = &new_table->head;
|
||
|
do {
|
||
|
entry = st_alloc_entry();
|
||
|
if (entry == 0) {
|
||
|
st_free_table(new_table);
|
||
|
return 0;
|
||
|
}
|
||
|
*entry = *ptr;
|
||
|
hash_val = hash_pos(entry->hash, num_bins);
|
||
|
entry->next = new_table->bins[hash_val];
|
||
|
new_table->bins[hash_val] = entry;
|
||
|
entry->back = prev;
|
||
|
*tailp = prev = entry;
|
||
|
tailp = &entry->fore;
|
||
|
} while ((ptr = ptr->fore) != 0);
|
||
|
new_table->tail = prev;
|
||
|
list_head_init(st_head(new_table));
|
||
|
list_for_each(st_head(old_table), ptr, olist) {
|
||
|
entry = new_entry(new_table, ptr->key, ptr->record, ptr->hash,
|
||
|
hash_pos(ptr->hash, num_bins));
|
||
|
list_add_tail(st_head(new_table), &entry->olist);
|
||
|
}
|
||
|
return new_table;
|
||
| ... | ... | |
|
static inline void
|
||
|
remove_entry(st_table *table, st_table_entry *ptr)
|
||
|
{
|
||
|
if (ptr->fore == 0 && ptr->back == 0) {
|
||
|
table->head = 0;
|
||
|
table->tail = 0;
|
||
|
}
|
||
|
else {
|
||
|
st_table_entry *fore = ptr->fore, *back = ptr->back;
|
||
|
if (fore) fore->back = back;
|
||
|
if (back) back->fore = fore;
|
||
|
if (ptr == table->head) table->head = fore;
|
||
|
if (ptr == table->tail) table->tail = back;
|
||
|
}
|
||
|
list_del(&ptr->olist);
|
||
|
table->num_entries--;
|
||
|
}
|
||
| ... | ... | |
|
int
|
||
|
st_shift(register st_table *table, register st_data_t *key, st_data_t *value)
|
||
|
{
|
||
|
st_table_entry *old;
|
||
|
st_table_entry **prev;
|
||
|
register st_table_entry *ptr;
|
||
| ... | ... | |
|
return 1;
|
||
|
}
|
||
|
prev = &table->bins[hash_pos(table->head->hash, table->num_bins)];
|
||
|
while ((ptr = *prev) != table->head) prev = &ptr->next;
|
||
|
old = list_pop(st_head(table), st_table_entry, olist);
|
||
|
table->num_entries--;
|
||
|
prev = &table->bins[hash_pos(old->hash, table->num_bins)];
|
||
|
while ((ptr = *prev) != old) prev = &ptr->next;
|
||
|
*prev = ptr->next;
|
||
|
if (value != 0) *value = ptr->record;
|
||
|
*key = ptr->key;
|
||
|
remove_entry(table, ptr);
|
||
|
st_free_entry(ptr);
|
||
|
return 1;
|
||
|
}
|
||
| ... | ... | |
|
int
|
||
|
st_foreach_check(st_table *table, int (*func)(ANYARGS), st_data_t arg, st_data_t never)
|
||
|
{
|
||
|
st_table_entry *ptr, **last, *tmp;
|
||
|
st_table_entry *ptr, **last, *tmp, *next, *resume_tail = 0;
|
||
|
struct list_head resume_head;
|
||
|
struct list_head *head;
|
||
|
enum st_retval retval;
|
||
|
st_index_t i;
|
||
| ... | ... | |
|
FIND_ENTRY(table, ptr, hash, i);
|
||
|
if (retval == ST_CHECK) {
|
||
|
if (!ptr) goto deleted;
|
||
|
goto unpacked_continue;
|
||
|
}
|
||
|
if (table->num_entries == 0) return 0;
|
||
|
resume_head.n = ptr->olist;
|
||
|
head = &resume_head;
|
||
|
next = list_next(st_head(table), ptr, olist);
|
||
|
resume_tail = list_tail(st_head(table), st_table_entry, olist);
|
||
|
goto unpacked;
|
||
|
}
|
||
|
switch (retval) {
|
||
| ... | ... | |
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
else {
|
||
|
ptr = table->head;
|
||
|
}
|
||
|
if (ptr != 0) {
|
||
|
do {
|
||
|
if (ptr->key == never)
|
||
|
goto unpacked_continue;
|
||
|
head = st_head(table);
|
||
|
list_for_each_safe(head, ptr, next, olist) {
|
||
|
if (ptr->key != never) {
|
||
|
i = hash_pos(ptr->hash, table->num_bins);
|
||
|
retval = (*func)(ptr->key, ptr->record, arg, 0);
|
||
|
unpacked:
|
||
| ... | ... | |
|
}
|
||
|
/* fall through */
|
||
|
case ST_CONTINUE:
|
||
|
unpacked_continue:
|
||
|
ptr = ptr->fore;
|
||
|
break;
|
||
|
case ST_STOP:
|
||
|
return 0;
|
||
| ... | ... | |
|
last = &table->bins[hash_pos(ptr->hash, table->num_bins)];
|
||
|
for (; (tmp = *last) != 0; last = &tmp->next) {
|
||
|
if (ptr == tmp) {
|
||
|
tmp = ptr->fore;
|
||
|
remove_entry(table, ptr);
|
||
|
ptr->key = ptr->record = never;
|
||
|
ptr->hash = 0;
|
||
|
ptr = tmp;
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
if (table->num_entries == 0) return 0;
|
||
|
}
|
||
|
} while (ptr && table->head);
|
||
|
}
|
||
|
if (resume_tail == ptr) break;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
| ... | ... | |
|
int
|
||
|
st_foreach(st_table *table, int (*func)(ANYARGS), st_data_t arg)
|
||
|
{
|
||
|
st_table_entry *ptr, **last, *tmp;
|
||
|
st_table_entry *ptr, **last, *tmp, *next, *resume_tail = 0;
|
||
|
enum st_retval retval;
|
||
|
struct list_head resume_head;
|
||
|
struct list_head *head;
|
||
|
st_index_t i;
|
||
|
if (table->entries_packed) {
|
||
| ... | ... | |
|
if (!table->entries_packed) {
|
||
|
FIND_ENTRY(table, ptr, hash, i);
|
||
|
if (!ptr) return 0;
|
||
|
resume_head.n = ptr->olist;
|
||
|
head = &resume_head;
|
||
|
next = list_next(st_head(table), ptr, olist);
|
||
|
resume_tail = list_tail(st_head(table), st_table_entry, olist);
|
||
|
goto unpacked;
|
||
|
}
|
||
|
switch (retval) {
|
||
| ... | ... | |
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
else {
|
||
|
ptr = table->head;
|
||
|
}
|
||
|
if (ptr != 0) {
|
||
|
do {
|
||
|
i = hash_pos(ptr->hash, table->num_bins);
|
||
|
retval = (*func)(ptr->key, ptr->record, arg, 0);
|
||
|
unpacked:
|
||
|
switch (retval) {
|
||
|
case ST_CONTINUE:
|
||
|
ptr = ptr->fore;
|
||
|
break;
|
||
|
case ST_CHECK:
|
||
|
case ST_STOP:
|
||
|
return 0;
|
||
|
case ST_DELETE:
|
||
|
last = &table->bins[hash_pos(ptr->hash, table->num_bins)];
|
||
|
for (; (tmp = *last) != 0; last = &tmp->next) {
|
||
|
if (ptr == tmp) {
|
||
|
tmp = ptr->fore;
|
||
|
*last = ptr->next;
|
||
|
remove_entry(table, ptr);
|
||
|
st_free_entry(ptr);
|
||
|
ptr = tmp;
|
||
|
break;
|
||
|
}
|
||
|
head = st_head(table);
|
||
|
list_for_each_safe(head, ptr, next, olist) {
|
||
|
i = hash_pos(ptr->hash, table->num_bins);
|
||
|
retval = (*func)(ptr->key, ptr->record, arg, 0);
|
||
|
unpacked:
|
||
|
switch (retval) {
|
||
|
case ST_CONTINUE:
|
||
|
break;
|
||
|
case ST_CHECK:
|
||
|
case ST_STOP:
|
||
|
return 0;
|
||
|
case ST_DELETE:
|
||
|
last = &table->bins[hash_pos(ptr->hash, table->num_bins)];
|
||
|
for (; (tmp = *last) != 0; last = &tmp->next) {
|
||
|
if (ptr == tmp) {
|
||
|
*last = ptr->next;
|
||
|
remove_entry(table, ptr);
|
||
|
st_free_entry(ptr);
|
||
|
break;
|
||
|
}
|
||
|
}
|
||
|
} while (ptr && table->head);
|
||
|
if (table->num_entries == 0) return 0;
|
||
|
}
|
||
|
if (resume_tail == ptr) break;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
| ... | ... | |
|
}
|
||
|
}
|
||
|
else {
|
||
|
st_table_entry *ptr = table->head;
|
||
|
st_table_entry *ptr;
|
||
|
st_data_t *keys_end = keys + size;
|
||
|
for (; ptr && keys < keys_end; ptr = ptr->fore) {
|
||
|
list_for_each(st_head(table), ptr, olist) {
|
||
|
if (keys >= keys_end) break;
|
||
|
key = ptr->key;
|
||
|
if (check && key == never) continue;
|
||
|
*keys++ = key;
|
||
| ... | ... | |
|
}
|
||
|
}
|
||
|
else {
|
||
|
st_table_entry *ptr = table->head;
|
||
|
st_table_entry *ptr;
|
||
|
st_data_t *values_end = values + size;
|
||
|
for (; ptr && values < values_end; ptr = ptr->fore) {
|
||
|
list_for_each(st_head(table), ptr, olist) {
|
||
|
if (values >= values_end) break;
|
||
|
key = ptr->key;
|
||
|
if (check && key == never) continue;
|
||
|
*values++ = ptr->record;
|
||
|
-
|
||