}
}
+/*
+ * The following is a VERY tight, efficent, hashtable for integer
+ * values and keys, and for nothing more. We could make our existing
+ * hashtable support type-genericness through a void * pointer but,
+ * ideally that would make things more complicated. We also don't need
+ * that much of a bloat for something as basic as this.
+ */
+typedef struct {
+ size_t key;
+ size_t value;
+} size_entry_t;
+#define ST_SIZE 1024
+
+typedef size_entry_t **size_table_t;
+
+size_table_t util_st_new() {
+ return (size_table_t)memset(
+ mem_a(sizeof(size_entry_t*) * ST_SIZE),
+ 0, ST_SIZE * sizeof(size_entry_t*)
+ );
+}
+void util_st_del(size_table_t table) {
+ size_t i = 0;
+ for (; i < ST_SIZE; i++) if(table[i]) mem_d(table[i]);
+ mem_d(table);
+}
+size_entry_t *util_st_get(size_table_t table, size_t key) {
+ size_t hash = (key % ST_SIZE);
+ while (table[hash] && table[hash]->key != key)
+ hash = (hash + 1) % ST_SIZE;
+ return table[hash];
+}
+void util_st_put(size_table_t table, size_t key, size_t value) {
+ size_t hash = (key % ST_SIZE);
+ while (table[hash] && table[hash]->key != key)
+ hash = (hash + 1) % ST_SIZE;
+ table[hash] = (size_entry_t*)mem_a(sizeof(size_entry_t));
+ table[hash]->key = key;
+ table[hash]->value = value;
+}
+
+static uint64_t strdups = 0;
+static uint64_t vectors = 0;
+static uint64_t vector_sizes = 0;
+static uint64_t hashtables = 0;
+static uint64_t hashtable_sizes = 0;
+static size_table_t vector_usage = NULL;
+static size_table_t hashtable_usage = NULL;
+
void util_meminfo() {
struct memblock_t *info;
-
if (OPTS_OPTION_BOOL(OPTION_DEBUG)) {
for (info = mem_start; info; info = info->next) {
con_out("lost: %u (bytes) at %s:%u\n",
(mem_at - mem_dt)
);
}
+
+ if (OPTS_OPTION_BOOL(OPTION_STATISTICS) ||
+ OPTS_OPTION_BOOL(OPTION_MEMCHK)) {
+ size_t i = 0;
+ size_t e = 1;
+ uint64_t vectormem = 0;
+
+ con_out("\nAdditional Statistics:\n\
+ Total vectors allocated: %llu\n\
+ Total string duplicates: %llu\n\
+ Total hashtables allocated: %llu\n\
+ Total unique vector sizes: %llu\n",
+ vectors,
+ strdups,
+ hashtables,
+ vector_sizes
+ );
+
+ for (; i < ST_SIZE; i++) {
+ size_entry_t *entry;
+
+ if (!(entry = vector_usage[i]))
+ continue;
+
+ con_out(" %2u| # of %4u byte vectors: %u\n",
+ (unsigned)e,
+ (unsigned)entry->key,
+ (unsigned)entry->value
+ );
+ e++;
+
+ vectormem += entry->key * entry->value;
+ }
+
+ con_out("\
+ Total unique hashtable sizes: %llu\n",
+ hashtable_sizes
+ );
+
+ for (i = 0, e = 1; i < ST_SIZE; i++) {
+ size_entry_t *entry;
+
+ if (!(entry = hashtable_usage[i]))
+ continue;
+
+ con_out(" %2u| # of %4u element hashtables: %u\n",
+ (unsigned)e,
+ (unsigned)entry->key,
+ (unsigned)entry->value
+ );
+ e++;
+ }
+
+ con_out(" Total vector memory: %f (MB)\n",
+ (float)(vectormem) / 1048576.0f
+ );
+ }
+
+ if (vector_usage)
+ util_st_del(vector_usage);
+ if (hashtable_usage)
+ util_st_del(hashtable_usage);
}
/*
memcpy(ptr, s, len);
ptr[len] = '\0';
}
+ strdups++;
return ptr;
}
memcpy(ptr, s, len);
ptr[len] = '\0';
}
+ strdups++;
return ptr;
}
/* TODO: rewrite ... when I redo the ve cleanup */
void _util_vec_grow(void **a, size_t i, size_t s) {
- vector_t *d = vec_meta(*a);
- size_t m = *a ? 2 * d->allocated +i : i+1;
- void *p = mem_r((*a ? d : NULL), s * m + sizeof(vector_t));
-
- if (!*a)
+ vector_t *d = vec_meta(*a);
+ size_t m = 0;
+ size_entry_t *e = NULL;
+ void *p = NULL;
+
+ if (*a) {
+ m = 2 * d->allocated + i;
+ p = mem_r(d, s * m + sizeof(vector_t));
+ } else {
+ m = i + 1;
+ p = mem_a(s * m + sizeof(vector_t));
((vector_t*)p)->used = 0;
- *a = (vector_t*)p + 1;
+ vectors++;
+ }
+
+ if (!vector_usage)
+ vector_usage = util_st_new();
+
+ if ((e = util_st_get(vector_usage, s))) {
+ e->value ++;
+ } else {
+ util_st_put(vector_usage, s, 1); /* start off with 1 */
+ vector_sizes++;
+ }
+ *a = (vector_t*)p + 1;
vec_meta(*a)->allocated = m;
}
return (size_t) (hash % ht->size);
}
-hash_node_t *_util_htnewpair(const char *key, void *value) {
+static hash_node_t *_util_htnewpair(const char *key, void *value) {
hash_node_t *node;
if (!(node = (hash_node_t*)mem_a(sizeof(hash_node_t))))
return NULL;
*/
hash_table_t *util_htnew(size_t size) {
hash_table_t *hashtable = NULL;
+ size_entry_t *find;
+
if (size < 1)
return NULL;
+
+ if (!hashtable_usage)
+ hashtable_usage = util_st_new();
if (!(hashtable = (hash_table_t*)mem_a(sizeof(hash_table_t))))
return NULL;
mem_d(hashtable);
return NULL;
}
+
+ if ((find = util_st_get(hashtable_usage, size)))
+ find->value++;
+ else {
+ hashtable_sizes++;
+ util_st_put(hashtable_usage, size, 1);
+ }
hashtable->size = size;
memset(hashtable->table, 0, sizeof(hash_node_t*) * size);
+ hashtables++;
return hashtable;
}
projects / xonotic / gmqcc.git / blobdiff