X-Git-Url: https://git.kengrimes.com/?p=henge%2Fapc.git;a=blobdiff_plain;f=src%2Ftestston.c;h=0c0fc19db1b7b3a210e10e5730ff721abe80ccca;hp=32910b0bc2806c3ce715f8e236ececf534e0dfe2;hb=6bcbbd2bd3710e13cad79b6822ef93e796d5e105;hpb=30e125e6bcfa71297ef4d592b0c80346f5688a1d diff --git a/src/testston.c b/src/testston.c index 32910b0..0c0fc19 100644 --- a/src/testston.c +++ b/src/testston.c @@ -1,7 +1,10 @@ #include //malloc #include //print #include //memcpy +#include //clock #include "../ston/ston.h" +#define XXH_PRIVATE_API +#include "../xxHash/xxhash.h" /* ansi terminal colors */ #define RED "\x1b[31m" @@ -13,97 +16,107 @@ #define CLRC "\x1b[0m" //clear current color #define CLRCN CLRC"\n" -#define print_val(val) do { \ - for (i = 0; i < (size_t)columns; i++) \ - printf("["YELLOW"%x"CLRC"]",val[i]); \ - printf("\n"); \ - } while(0) +#define startclock(_STR) do { \ + start = clock(); \ + printf(_STR": "); \ + } while (0) -#define check_ht(_HT) \ - if ((_HT) == NULL) \ - { fprintf(stderr,RED"Could not allocate ht32"CLRCN); \ - return -1; \ - } \ - else \ - printf("ht_size: [units:%i][bytes:%li]\n",ston_ht_size(ht),ston_ht32_size(ht)); \ +#define startclockf(_STR,...) do { \ + start = clock(); \ + printf(_STR": ",__VA_ARGS__); \ + } while (0) + +#define endclock() do { \ + end = clock(); \ + printf("%5f",(end - start)/(double)CLOCKS_PER_SEC); \ + } while (0) +#define endclockn() do { \ + end = clock(); \ + printf("%5f\n",(end - start)/(double)CLOCKS_PER_SEC); \ + } while (0) + +#define $($)#$ +#define do_test(_COL,_COUNT,_HT,_FREE,_HTNEW,_HTINSERT,_HTROW,_SEED) do { \ + printf("[ " $(_HT) " ] "); \ + columns = _COL; \ + count = _COUNT; \ + _HT = _HTNEW; \ + startclockf("Filling " $(_HT) " with %i entries",count); \ + while (count--) \ + { key = XXH32(&count,4,_SEED); \ + val[0] = key; \ + for (i = 0; i < columns; i++) \ + val[i] = key - i; \ + _HTINSERT(_HT,key,val,0,columns); \ + } \ + endclockn(); \ + count = _COUNT; \ + fail = 0; \ + startclock("Reading entries"); \ + while (count--) \ + { key = XXH32(&count,4,_SEED); \ + htval = _HTROW(_HT,key); \ + if (htval == NULL) \ + { fail++; \ + printf("Row returned null\n"); \ + break; \ + } \ + if (*htval != key) \ + fail++; \ + for (i = 1; i < columns; i++) \ + if (htval[i] != key - i) \ + fail++; \ + } \ + endclock(); \ + if (fail) \ + printf(RED"\nFAIL"CLRC"(%i)\n", fail); \ + else \ + printf(GREEN"\nPASS"CLRCN); \ + _FREE(_HT); \ + } while (0) int main(int argc, char* argv[]) { static ston_ht ht; - uint32_t* htval, previous_val; + static ston_dht dht; uint32_t val[255], key; - size_t idx; + uint32_t* htval; size_t i; - size_t elements; uint16_t columns; + int fail; + clock_t start, end; + int count; + printf("\nLow usage:\n"); + do_test(2,200,ht,free,ston_ht32_new(2,200,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(5,200,ht,free,ston_ht32_new(5,200,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(2,200,dht,ston_dht_free,ston_dht32_new(2,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); + do_test(5,200,dht,ston_dht_free,ston_dht32_new(5,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); - printf("up2pow [5] = [%i]\n",ston_up2pow(5)); - for (i = 0; i < 255; i += 7) - printf("trailing0 [%X] = [%x]\n",(uint32_t)i,ston_trailing0(i)); + printf("\nLow-mid usage:\n"); + do_test(2,10000,ht,free,ston_ht32_new(2,10000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(5,10000,ht,free,ston_ht32_new(5,10000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(2,10000,dht,ston_dht_free,ston_dht32_new(2,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); + do_test(5,10000,dht,ston_dht_free,ston_dht32_new(5,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); - columns = 2; - elements = 1; - ht = ston_ht32_new(columns,elements,0,malloc); - check_ht(ht); - key = 0xFF; - val[0] = key; - val[1] = 0x5; - printf("ht32_insertx: [%x] = ", key); - print_val(val); - ston_ht32_insertx(ht,key,val,0,columns); - idx = 1; - htval = ston_ht32_row(ht,key); - printf("Read value [%x] matches: %s"CLRCN, htval[idx], - (htval[idx] == val[idx]) ? GREEN"PASS" : RED"FAIL"); + printf("\nMid usage:\n"); + do_test(2,500000,ht,free,ston_ht32_new(2,500000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(5,500000,ht,free,ston_ht32_new(5,500000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(2,500000,dht,ston_dht_free,ston_dht32_new(2,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); + do_test(5,500000,dht,ston_dht_free,ston_dht32_new(5,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); - val[1] = 0x2; - previous_val = ston_ht32_insert(ht,key,1,val[1]); - printf("ht32_insert: [%x] = ", key); - print_val(val); - printf("Previous value [%x] matches [5]: %s"CLRCN, previous_val, - (previous_val == 0x5) ? GREEN"PASS" : RED"FAIL"); + printf("\nMid-high usage:\n"); + do_test(2,9000000,ht,free,ston_ht32_new(2,9000000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(5,9000000,ht,free,ston_ht32_new(5,9000000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); + do_test(2,9000000,dht,ston_dht_free,ston_dht32_new(2,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); + do_test(2,9000000,dht,ston_dht_free,ston_dht32_new(5,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); - free(ht); + /* printf("\nHigh usage:\n"); */ + /* do_test(2,90000000,ht,free,ston_ht32_new(2,90000000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); */ + /* do_test(2,90000000,dht,ston_dht_free,ston_dht32_new(2,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); */ - columns = 4; - elements = 20; - ht = ston_ht32_new(columns,elements,0,malloc); - check_ht(ht); - printf("Filling hashtable with entries\n"); - for(key = 0xCEED; elements--; key *= 7) - { val[0] = key; - for(i = 1; i < columns; i++) - val[i] = i * key; - ston_ht32_insertx(ht,key,val,0,columns); - } - printf("Reading entries\n"); - elements = 20; - for(key = 0xCEED; elements--; key *= 7) - { htval = ston_ht32_row(ht,key); - printf("[%s%x"CLRC"]",(*htval == key) ? GREEN : RED,*htval); - for(i = 1; i < columns; i++) - printf("[%s%x"CLRC"]",(htval[i] == (uint32_t)(i * key)) ? GREEN : RED,htval[i]); - putchar('\n'); - } - int max_capacity = ston_up2pow(20 << 1) - 20; - printf("Overfilling hashtable with %i entries\n", max_capacity); - int cap = max_capacity; - for(key = 0xCEED2; cap--; key *= 13) - { val[0] = key; - for(i = 1; i < columns; i++) - val[i] = key * -i; - ston_ht32_insertx(ht,key,val,0,columns); - } - printf("Reading entries\n"); - cap = max_capacity; - for(key = 0xCEED2; cap--; key *= 13) - { htval = ston_ht32_row(ht,key); - printf("[%s%x"CLRC"]",(*htval == key) ? GREEN : RED,*htval); - for(i = 1; i < columns; i++) - printf("[%s%x"CLRC"]",(htval[i] == (uint32_t)(key * -i)) ? GREEN : RED,htval[i]); - printf("\n"); - } + /* printf("\nHuge usage:\n"); */ + /* do_test(2,100000000,ht,free,ston_ht32_new(2,100000000,0,malloc),ston_ht32_insertx,ston_ht32_row,0xCEED); */ + /* do_test(2,100000000,dht,ston_dht_free,ston_dht32_new(2,malloc,free),ston_dht32_insertx,ston_dht32_row,0xCEED); */ - free(ht); - return 0; + printf("\nDONE\n"); }