X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=util.c;h=351aba6d8bb4732357a779a1765280237d82fd33;hp=b7e3c7c7295625ac395fdccb49656edccb7b8491;hb=79a7aa70b9b09d54e2257afc0d9efea59a408849;hpb=160e7cf7eebd7fa173fb739aca00143097a3518b diff --git a/util.c b/util.c index b7e3c7c..351aba6 100644 --- a/util.c +++ b/util.c @@ -26,12 +26,12 @@ #include "gmqcc.h" /* TODO: remove globals ... */ -uint64_t mem_ab = 0; -uint64_t mem_db = 0; -uint64_t mem_at = 0; -uint64_t mem_dt = 0; -uint64_t mem_pk = 0; -uint64_t mem_hw = 0; +static uint64_t mem_ab = 0; +static uint64_t mem_db = 0; +static uint64_t mem_at = 0; +static uint64_t mem_dt = 0; +static uint64_t mem_pk = 0; +static uint64_t mem_hw = 0; struct memblock_t { const char *file; @@ -167,10 +167,55 @@ static void util_dumpmem(struct memblock_t *memory, uint16_t cols) { } } +/* + * 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 size_table_t vector_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", @@ -202,6 +247,38 @@ void util_meminfo() { (mem_at - mem_dt) ); } + + if (OPTS_OPTION_BOOL(OPTION_STATISTICS) || + OPTS_OPTION_BOOL(OPTION_MEMCHK)) { + size_t i=0; + size_t e=1; + + con_out("Additional Statistics:\n\ + Total vectors allocated: %u\n\ + Total string duplicates: %u\n\ + Total unique vector sizes: %u\n", + (unsigned)vectors, + (unsigned)strdups, + (unsigned)vector_sizes + ); + + for (; i < ST_SIZE; i++) { + size_entry_t *entry; + + if (!(entry = vector_usage[i])) + continue; + + con_out(" %u| # of %3u (bytes) vectors: %u\n", + (unsigned)e, + (unsigned)entry->key, + (unsigned)entry->value + ); + e++; + } + } + + if (vector_usage) + util_st_del(vector_usage); } /* @@ -223,6 +300,7 @@ char *_util_Estrdup(const char *s, const char *file, size_t line) { memcpy(ptr, s, len); ptr[len] = '\0'; } + strdups++; return ptr; } @@ -242,6 +320,7 @@ char *_util_Estrdup_empty(const char *s, const char *file, size_t line) { memcpy(ptr, s, len); ptr[len] = '\0'; } + strdups++; return ptr; } @@ -434,14 +513,32 @@ size_t util_strtononcmd(const char *in, char *out, size_t outsz) { /* 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; } @@ -465,8 +562,7 @@ GMQCC_INLINE size_t util_hthash(hash_table_t *ht, const char *key) { const unsigned char *data = (const unsigned char*)key; while (size >= 4) { - alias = *(uint32_t*)data; - + alias = (data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24)); alias *= mix; alias ^= alias >> rot; alias *= mix; @@ -492,7 +588,7 @@ GMQCC_INLINE size_t util_hthash(hash_table_t *ht, const char *key) { 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; @@ -688,14 +784,13 @@ int util_vasprintf(char **dat, const char *fmt, va_list args) { * will return the required amount to allocate. */ #ifdef _MSC_VER - char *str; if ((len = _vscprintf(fmt, args)) < 0) { *dat = NULL; return -1; } - tmp = mem_a(len + 1); - if ((ret = _vsnprintf(tmp, len+1, fmt, args)) != len) { + tmp = (char*)mem_a(len + 1); + if ((ret = _vsnprintf_s(tmp, len+1, len+1, fmt, args)) != len) { mem_d(tmp); *dat = NULL; return -1; @@ -742,6 +837,92 @@ int util_asprintf(char **ret, const char *fmt, ...) { return read; } +/* + * These are various re-implementations (wrapping the real ones) of + * string functions that MSVC consideres unsafe. We wrap these up and + * use the safe varations on MSVC. + */ +#ifdef _MSC_VER + static char **util_strerror_allocated() { + static char **data = NULL; + return data; + } + + static void util_strerror_cleanup(void) { + size_t i; + char **data = util_strerror_allocated(); + for (i = 0; i < vec_size(data); i++) + mem_d(data[i]); + vec_free(data); + } + + const char *util_strerror(int num) { + char *allocated = NULL; + static bool install = false; + static size_t tries = 0; + char **vector = util_strerror_allocated(); + + /* try installing cleanup handler */ + while (!install) { + if (tries == 32) + return "(unknown)"; + + install = !atexit(&util_strerror_cleanup); + tries ++; + } + + allocated = (char*)mem_a(4096); /* A page must be enough */ + strerror_s(allocated, 4096, num); + + vec_push(vector, allocated); + return (const char *)allocated; + } + + int util_snprintf(char *src, size_t bytes, const char *format, ...) { + int rt; + va_list va; + va_start(va, format); + + rt = vsprintf_s(src, bytes, format, va); + va_end (va); + + return rt; + } + + char *util_strcat(char *dest, const char *src) { + strcat_s(dest, strlen(src), src); + return dest; + } + + char *util_strncpy(char *dest, const char *src, size_t num) { + strncpy_s(dest, num, src, num); + return dest; + } +#else + const char *util_strerror(int num) { + return strerror(num); + } + + int util_snprintf(char *src, size_t bytes, const char *format, ...) { + int rt; + va_list va; + va_start(va, format); + rt = vsnprintf(src, bytes, format, va); + va_end (va); + + return rt; + } + + char *util_strcat(char *dest, const char *src) { + return strcat(dest, src); + } + + char *util_strncpy(char *dest, const char *src, size_t num) { + return strncpy(dest, src, num); + } + +#endif /*! _MSC_VER */ + /* * Implementation of the Mersenne twister PRNG (pseudo random numer * generator). Implementation of MT19937. Has a period of 2^19937-1