16 |
17 | #include "../palm/palm_tree.h"
18 | #include "../palm/metric.h"
19 |
20 | static const uint64_t value = 3190;
21 | static char *file_str;
22 | static int queue_size;
23 | static int thread_number;
24 | static int total_keys;
25 |
26 | static long long mstime()
27 | {
28 | struct timeval tv;
29 | long long ust;
30 |
31 | gettimeofday(&tv, NULL);
32 | ust = ((long long)tv.tv_sec)*1000000;
33 | ust += tv.tv_usec;
34 | return ust / 1000;
35 | }
36 |
37 | void test_palm_tree()
38 | {
39 | palm_tree *pt = new_palm_tree(thread_number, queue_size);
40 | batch *batches[queue_size + 1];
41 | for (int i = 0; i < queue_size + 1; ++i)
42 | batches[i] = new_batch();
43 |
44 | char file_name[32];
45 | memset(file_name, 0, 32);
46 | memcpy(file_name, "./data/", 7);
47 | memcpy(file_name + 7, file_str, strlen(file_str));
48 |
49 | int fd = open(file_name, O_RDONLY);
50 | assert(fd > 0);
51 | int block = 65536, curr = 0, ptr = 0, count = 0;
52 | char buf[block];
53 | int flag = 1;
54 | long long before = mstime();
55 | int idx = 0;
56 | batch *cb = batches[idx];
57 | for (; (ptr = pread(fd, buf, block, curr)) > 0 && flag; curr += ptr) {
58 | while (--ptr && buf[ptr] != '\n' && buf[ptr] != '\0') buf[ptr] = '\0';
59 | if (ptr) buf[ptr++] = '\0';
60 | else break;
61 | for (int i = 0; i < ptr; ++i) {
62 | char *key = buf + i, *tmp = key;
63 | uint32_t len = 0;
64 | while (tmp[len] != '\0' && tmp[len] != '\n')
65 | ++len;
66 | tmp[len] = '\0';
67 | i += len;
68 |
69 | if (count && (count % 1000000) == 0)
70 | printf("%d\n", count);
71 |
72 | if (count++ == total_keys) {
73 | flag = 0;
74 | break;
75 | }
76 |
77 | if (batch_add_write(cb, key, len, (void *)value) == -1) {
78 | palm_tree_execute(pt, cb);
79 | idx = idx == queue_size ? 0 : idx + 1;
80 | cb = batches[idx];
81 | batch_clear(cb);
82 | assert(batch_add_write(cb, key, len, (void *)value) == 1);
83 | }
84 | }
85 | }
86 |
87 | // finish remained work
88 | palm_tree_execute(pt, cb);
89 | palm_tree_flush(pt);
90 |
91 | long long after = mstime();
92 | printf("\033[31mtotal: %d\033[0m\n\033[32mput time: %.4f s\033[0m\n", total_keys, (float)(after - before) / 1000);
93 | show_metric();
94 |
95 | for (int i = 0; i < queue_size + 1; ++i)
96 | batch_clear(batches[i]);
97 |
98 | // palm_tree_validate(pt);
99 |
100 | curr = 0;
101 | flag = 1;
102 | count = 0;
103 | before = mstime();
104 | for (; (ptr = pread(fd, buf, block, curr)) > 0 && flag; curr += ptr) {
105 | while (--ptr && buf[ptr] != '\n' && buf[ptr] != '\0') buf[ptr] = '\0';
106 | if (ptr) buf[ptr++] = '\0';
107 | else break;
108 | for (int i = 0; i < ptr; ++i) {
109 | char *key = buf + i, *tmp = key;
110 | uint32_t len = 0;
111 | while (tmp[len] != '\0' && tmp[len] != '\n')
112 | ++len;
113 | tmp[len] = '\0';
114 | i += len;
115 |
116 | if (count && (count % 1000000) == 0)
117 | printf("%d\n", count);
118 |
119 | if (count++ == total_keys) {
120 | flag = 0;
121 | break;
122 | }
123 |
124 | if (batch_add_read(cb, key, len) == -1) {
125 | palm_tree_execute(pt, cb);
126 | idx = idx == queue_size ? 0 : idx + 1;
127 | cb = batches[idx];
128 | for (uint32_t j = 0; j < cb->keys; ++j)
129 | assert((uint64_t)batch_get_value_at(cb, j) == value);
130 | batch_clear(cb);
131 | assert(batch_add_read(cb, key, len) == 1);
132 | }
133 | }
134 | }
135 |
136 | // finish remained work
137 | palm_tree_execute(pt, cb);
138 | palm_tree_flush(pt);
139 |
140 | for (int i = 0; i < queue_size + 1; ++i) {
141 | cb = batches[i];
142 | for (uint32_t j = 0; j < cb->keys; ++j)
143 | assert((uint64_t)batch_get_value_at(cb, j) == value);
144 | }
145 |
146 | after = mstime();
147 | printf("\033[34mget time: %.4f s\033[0m\n", (float)(after - before) / 1000);
148 |
149 | close(fd);
150 |
151 | show_metric();
152 |
153 | for (int i = 0; i < queue_size + 1; ++i)
154 | free_batch(batches[i]);
155 |
156 | free_palm_tree(pt);
157 | }
158 |
159 | int main(int argc, char **argv)
160 | {
161 | if (argc < 7) {
162 | printf("file_name node_size batch_size thread_number queue_size key_number\n");
163 | exit(1);
164 | }
165 |
166 | file_str = argv[1];
167 | int node_size = atoi(argv[2]);
168 | int batch_size = atoi(argv[3]);
169 | thread_number = atoi(argv[4]);
170 | queue_size = atoi(argv[5]);
171 | total_keys = atoi(argv[6]);
172 | if (total_keys <= 0) total_keys = 1;
173 | if (queue_size <= 0) queue_size = 1;
174 | if (thread_number <= 0) thread_number = 1;
175 | set_node_size(node_size);
176 | set_batch_size(batch_size);
177 |
178 | test_palm_tree();
179 |
180 | return 0;
181 | }
182 |
--------------------------------------------------------------------------------
/third_party/c_hashmap/License.md:
--------------------------------------------------------------------------------
1 |
2 |
4 | 
5 |
6 |
7 | To the extent possible under law,
8 |
10 | Pete Warden
11 | has waived all copyright and related or neighboring rights to
12 | C hashmap.
13 |
14 |
--------------------------------------------------------------------------------
/third_party/c_hashmap/README:
--------------------------------------------------------------------------------
1 | This is a simple C hashmap, using strings for the keys.
2 |
3 | Originally based on code by Eliot Back at http://elliottback.com/wp/hashmap-implementation-in-c/
4 | Reworked by Pete Warden - http://petewarden.typepad.com/searchbrowser/2010/01/c-hashmap.html
5 |
6 | main.c contains an example that tests the functionality of the hashmap module.
7 | To compile it, run something like this on your system:
8 | gcc main.c hashmap.c -o hashmaptest
9 |
10 | There are no restrictions on how you reuse this code.
--------------------------------------------------------------------------------
/third_party/c_hashmap/hashmap.c:
--------------------------------------------------------------------------------
1 | /*
2 | * Generic map implementation.
3 | */
4 | #include "hashmap.h"
5 |
6 | #include
7 | #include
8 | #include
9 |
10 | #define INITIAL_SIZE (256)
11 | #define MAX_CHAIN_LENGTH (8)
12 |
13 | /* We need to keep keys and values */
14 | typedef struct _hashmap_element{
15 | char* key;
16 | int in_use;
17 | any_t data;
18 | } hashmap_element;
19 |
20 | /* A hashmap has some maximum size and current size,
21 | * as well as the data to hold. */
22 | typedef struct _hashmap_map{
23 | int table_size;
24 | int size;
25 | hashmap_element *data;
26 | } hashmap_map;
27 |
28 | /*
29 | * Return an empty hashmap, or NULL on failure.
30 | */
31 | map_t hashmap_new() {
32 | hashmap_map* m = (hashmap_map*) malloc(sizeof(hashmap_map));
33 | if(!m) goto err;
34 |
35 | m->data = (hashmap_element*) calloc(INITIAL_SIZE, sizeof(hashmap_element));
36 | if(!m->data) goto err;
37 |
38 | m->table_size = INITIAL_SIZE;
39 | m->size = 0;
40 |
41 | return m;
42 | err:
43 | if (m)
44 | hashmap_free(m);
45 | return NULL;
46 | }
47 |
48 | /* The implementation here was originally done by Gary S. Brown. I have
49 | borrowed the tables directly, and made some minor changes to the
50 | crc32-function (including changing the interface). //ylo */
51 |
52 | /* ============================================================= */
53 | /* COPYRIGHT (C) 1986 Gary S. Brown. You may use this program, or */
54 | /* code or tables extracted from it, as desired without restriction. */
55 | /* */
56 | /* First, the polynomial itself and its table of feedback terms. The */
57 | /* polynomial is */
58 | /* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
59 | /* */
60 | /* Note that we take it "backwards" and put the highest-order term in */
61 | /* the lowest-order bit. The X^32 term is "implied"; the LSB is the */
62 | /* X^31 term, etc. The X^0 term (usually shown as "+1") results in */
63 | /* the MSB being 1. */
64 | /* */
65 | /* Note that the usual hardware shift register implementation, which */
66 | /* is what we're using (we're merely optimizing it by doing eight-bit */
67 | /* chunks at a time) shifts bits into the lowest-order term. In our */
68 | /* implementation, that means shifting towards the right. Why do we */
69 | /* do it this way? Because the calculated CRC must be transmitted in */
70 | /* order from highest-order term to lowest-order term. UARTs transmit */
71 | /* characters in order from LSB to MSB. By storing the CRC this way, */
72 | /* we hand it to the UART in the order low-byte to high-byte; the UART */
73 | /* sends each low-bit to hight-bit; and the result is transmission bit */
74 | /* by bit from highest- to lowest-order term without requiring any bit */
75 | /* shuffling on our part. Reception works similarly. */
76 | /* */
77 | /* The feedback terms table consists of 256, 32-bit entries. Notes: */
78 | /* */
79 | /* The table can be generated at runtime if desired; code to do so */
80 | /* is shown later. It might not be obvious, but the feedback */
81 | /* terms simply represent the results of eight shift/xor opera- */
82 | /* tions for all combinations of data and CRC register values. */
83 | /* */
84 | /* The values must be right-shifted by eight bits by the "updcrc" */
85 | /* logic; the shift must be unsigned (bring in zeroes). On some */
86 | /* hardware you could probably optimize the shift in assembler by */
87 | /* using byte-swap instructions. */
88 | /* polynomial $edb88320 */
89 | /* */
90 | /* -------------------------------------------------------------------- */
91 |
92 | static unsigned long crc32_tab[] = {
93 | 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L,
94 | 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L,
95 | 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L,
96 | 0x90bf1d91L, 0x1db71064L, 0x6ab020f2L, 0xf3b97148L, 0x84be41deL,
97 | 0x1adad47dL, 0x6ddde4ebL, 0xf4d4b551L, 0x83d385c7L, 0x136c9856L,
98 | 0x646ba8c0L, 0xfd62f97aL, 0x8a65c9ecL, 0x14015c4fL, 0x63066cd9L,
99 | 0xfa0f3d63L, 0x8d080df5L, 0x3b6e20c8L, 0x4c69105eL, 0xd56041e4L,
100 | 0xa2677172L, 0x3c03e4d1L, 0x4b04d447L, 0xd20d85fdL, 0xa50ab56bL,
101 | 0x35b5a8faL, 0x42b2986cL, 0xdbbbc9d6L, 0xacbcf940L, 0x32d86ce3L,
102 | 0x45df5c75L, 0xdcd60dcfL, 0xabd13d59L, 0x26d930acL, 0x51de003aL,
103 | 0xc8d75180L, 0xbfd06116L, 0x21b4f4b5L, 0x56b3c423L, 0xcfba9599L,
104 | 0xb8bda50fL, 0x2802b89eL, 0x5f058808L, 0xc60cd9b2L, 0xb10be924L,
105 | 0x2f6f7c87L, 0x58684c11L, 0xc1611dabL, 0xb6662d3dL, 0x76dc4190L,
106 | 0x01db7106L, 0x98d220bcL, 0xefd5102aL, 0x71b18589L, 0x06b6b51fL,
107 | 0x9fbfe4a5L, 0xe8b8d433L, 0x7807c9a2L, 0x0f00f934L, 0x9609a88eL,
108 | 0xe10e9818L, 0x7f6a0dbbL, 0x086d3d2dL, 0x91646c97L, 0xe6635c01L,
109 | 0x6b6b51f4L, 0x1c6c6162L, 0x856530d8L, 0xf262004eL, 0x6c0695edL,
110 | 0x1b01a57bL, 0x8208f4c1L, 0xf50fc457L, 0x65b0d9c6L, 0x12b7e950L,
111 | 0x8bbeb8eaL, 0xfcb9887cL, 0x62dd1ddfL, 0x15da2d49L, 0x8cd37cf3L,
112 | 0xfbd44c65L, 0x4db26158L, 0x3ab551ceL, 0xa3bc0074L, 0xd4bb30e2L,
113 | 0x4adfa541L, 0x3dd895d7L, 0xa4d1c46dL, 0xd3d6f4fbL, 0x4369e96aL,
114 | 0x346ed9fcL, 0xad678846L, 0xda60b8d0L, 0x44042d73L, 0x33031de5L,
115 | 0xaa0a4c5fL, 0xdd0d7cc9L, 0x5005713cL, 0x270241aaL, 0xbe0b1010L,
116 | 0xc90c2086L, 0x5768b525L, 0x206f85b3L, 0xb966d409L, 0xce61e49fL,
117 | 0x5edef90eL, 0x29d9c998L, 0xb0d09822L, 0xc7d7a8b4L, 0x59b33d17L,
118 | 0x2eb40d81L, 0xb7bd5c3bL, 0xc0ba6cadL, 0xedb88320L, 0x9abfb3b6L,
119 | 0x03b6e20cL, 0x74b1d29aL, 0xead54739L, 0x9dd277afL, 0x04db2615L,
120 | 0x73dc1683L, 0xe3630b12L, 0x94643b84L, 0x0d6d6a3eL, 0x7a6a5aa8L,
121 | 0xe40ecf0bL, 0x9309ff9dL, 0x0a00ae27L, 0x7d079eb1L, 0xf00f9344L,
122 | 0x8708a3d2L, 0x1e01f268L, 0x6906c2feL, 0xf762575dL, 0x806567cbL,
123 | 0x196c3671L, 0x6e6b06e7L, 0xfed41b76L, 0x89d32be0L, 0x10da7a5aL,
124 | 0x67dd4accL, 0xf9b9df6fL, 0x8ebeeff9L, 0x17b7be43L, 0x60b08ed5L,
125 | 0xd6d6a3e8L, 0xa1d1937eL, 0x38d8c2c4L, 0x4fdff252L, 0xd1bb67f1L,
126 | 0xa6bc5767L, 0x3fb506ddL, 0x48b2364bL, 0xd80d2bdaL, 0xaf0a1b4cL,
127 | 0x36034af6L, 0x41047a60L, 0xdf60efc3L, 0xa867df55L, 0x316e8eefL,
128 | 0x4669be79L, 0xcb61b38cL, 0xbc66831aL, 0x256fd2a0L, 0x5268e236L,
129 | 0xcc0c7795L, 0xbb0b4703L, 0x220216b9L, 0x5505262fL, 0xc5ba3bbeL,
130 | 0xb2bd0b28L, 0x2bb45a92L, 0x5cb36a04L, 0xc2d7ffa7L, 0xb5d0cf31L,
131 | 0x2cd99e8bL, 0x5bdeae1dL, 0x9b64c2b0L, 0xec63f226L, 0x756aa39cL,
132 | 0x026d930aL, 0x9c0906a9L, 0xeb0e363fL, 0x72076785L, 0x05005713L,
133 | 0x95bf4a82L, 0xe2b87a14L, 0x7bb12baeL, 0x0cb61b38L, 0x92d28e9bL,
134 | 0xe5d5be0dL, 0x7cdcefb7L, 0x0bdbdf21L, 0x86d3d2d4L, 0xf1d4e242L,
135 | 0x68ddb3f8L, 0x1fda836eL, 0x81be16cdL, 0xf6b9265bL, 0x6fb077e1L,
136 | 0x18b74777L, 0x88085ae6L, 0xff0f6a70L, 0x66063bcaL, 0x11010b5cL,
137 | 0x8f659effL, 0xf862ae69L, 0x616bffd3L, 0x166ccf45L, 0xa00ae278L,
138 | 0xd70dd2eeL, 0x4e048354L, 0x3903b3c2L, 0xa7672661L, 0xd06016f7L,
139 | 0x4969474dL, 0x3e6e77dbL, 0xaed16a4aL, 0xd9d65adcL, 0x40df0b66L,
140 | 0x37d83bf0L, 0xa9bcae53L, 0xdebb9ec5L, 0x47b2cf7fL, 0x30b5ffe9L,
141 | 0xbdbdf21cL, 0xcabac28aL, 0x53b39330L, 0x24b4a3a6L, 0xbad03605L,
142 | 0xcdd70693L, 0x54de5729L, 0x23d967bfL, 0xb3667a2eL, 0xc4614ab8L,
143 | 0x5d681b02L, 0x2a6f2b94L, 0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL,
144 | 0x2d02ef8dL
145 | };
146 |
147 | /* Return a 32-bit CRC of the contents of the buffer. */
148 |
149 | unsigned long crc32(const unsigned char *s, unsigned int len)
150 | {
151 | unsigned int i;
152 | unsigned long crc32val;
153 |
154 | crc32val = 0;
155 | for (i = 0; i < len; i ++)
156 | {
157 | crc32val =
158 | crc32_tab[(crc32val ^ s[i]) & 0xff] ^
159 | (crc32val >> 8);
160 | }
161 | return crc32val;
162 | }
163 |
164 | /*
165 | * Hashing function for a string
166 | */
167 | unsigned int hashmap_hash_int(hashmap_map * m, char* keystring){
168 |
169 | unsigned long key = crc32((unsigned char*)(keystring), strlen(keystring));
170 |
171 | /* Robert Jenkins' 32 bit Mix Function */
172 | key += (key << 12);
173 | key ^= (key >> 22);
174 | key += (key << 4);
175 | key ^= (key >> 9);
176 | key += (key << 10);
177 | key ^= (key >> 2);
178 | key += (key << 7);
179 | key ^= (key >> 12);
180 |
181 | /* Knuth's Multiplicative Method */
182 | key = (key >> 3) * 2654435761;
183 |
184 | return key % m->table_size;
185 | }
186 |
187 | /*
188 | * Return the integer of the location in data
189 | * to store the point to the item, or MAP_FULL.
190 | */
191 | int hashmap_hash(map_t in, char* key){
192 | int curr;
193 | int i;
194 |
195 | /* Cast the hashmap */
196 | hashmap_map* m = (hashmap_map *) in;
197 |
198 | /* If full, return immediately */
199 | if(m->size >= (m->table_size/2)) return MAP_FULL;
200 |
201 | /* Find the best index */
202 | curr = hashmap_hash_int(m, key);
203 |
204 | /* Linear probing */
205 | for(i = 0; i< MAX_CHAIN_LENGTH; i++){
206 | if(m->data[curr].in_use == 0)
207 | return curr;
208 |
209 | if(m->data[curr].in_use == 1 && (strcmp(m->data[curr].key,key)==0))
210 | return curr;
211 |
212 | curr = (curr + 1) % m->table_size;
213 | }
214 |
215 | return MAP_FULL;
216 | }
217 |
218 | /*
219 | * Doubles the size of the hashmap, and rehashes all the elements
220 | */
221 | int hashmap_rehash(map_t in){
222 | int i;
223 | int old_size;
224 | hashmap_element* curr;
225 |
226 | /* Setup the new elements */
227 | hashmap_map *m = (hashmap_map *) in;
228 | hashmap_element* temp = (hashmap_element *)
229 | calloc(2 * m->table_size, sizeof(hashmap_element));
230 | if(!temp) return MAP_OMEM;
231 |
232 | /* Update the array */
233 | curr = m->data;
234 | m->data = temp;
235 |
236 | /* Update the size */
237 | old_size = m->table_size;
238 | m->table_size = 2 * m->table_size;
239 | m->size = 0;
240 |
241 | /* Rehash the elements */
242 | for(i = 0; i < old_size; i++){
243 | int status;
244 |
245 | if (curr[i].in_use == 0)
246 | continue;
247 |
248 | status = hashmap_put(m, curr[i].key, curr[i].data);
249 | if (status != MAP_OK)
250 | return status;
251 | }
252 |
253 | free(curr);
254 |
255 | return MAP_OK;
256 | }
257 |
258 | /*
259 | * Add a pointer to the hashmap with some key
260 | */
261 | int hashmap_put(map_t in, char* key, any_t value){
262 | int index;
263 | hashmap_map* m;
264 |
265 | /* Cast the hashmap */
266 | m = (hashmap_map *) in;
267 |
268 | /* Find a place to put our value */
269 | index = hashmap_hash(in, key);
270 | while(index == MAP_FULL){
271 | if (hashmap_rehash(in) == MAP_OMEM) {
272 | return MAP_OMEM;
273 | }
274 | index = hashmap_hash(in, key);
275 | }
276 |
277 | /* Set the data */
278 | m->data[index].data = value;
279 | m->data[index].key = key;
280 | m->data[index].in_use = 1;
281 | m->size++;
282 |
283 | return MAP_OK;
284 | }
285 |
286 | /*
287 | * Get your pointer out of the hashmap with a key
288 | */
289 | int hashmap_get(map_t in, char* key, any_t *arg){
290 | int curr;
291 | int i;
292 | hashmap_map* m;
293 |
294 | /* Cast the hashmap */
295 | m = (hashmap_map *) in;
296 |
297 | /* Find data location */
298 | curr = hashmap_hash_int(m, key);
299 |
300 | /* Linear probing, if necessary */
301 | for(i = 0; idata[curr].in_use;
304 | if (in_use == 1){
305 | if (strcmp(m->data[curr].key,key)==0){
306 | *arg = (m->data[curr].data);
307 | return MAP_OK;
308 | }
309 | }
310 |
311 | curr = (curr + 1) % m->table_size;
312 | }
313 |
314 | *arg = NULL;
315 |
316 | /* Not found */
317 | return MAP_MISSING;
318 | }
319 |
320 | /*
321 | * Iterate the function parameter over each element in the hashmap. The
322 | * additional any_t argument is passed to the function as its first
323 | * argument and the hashmap element is the second.
324 | */
325 | int hashmap_iterate(map_t in, PFany f, any_t item) {
326 | int i;
327 |
328 | /* Cast the hashmap */
329 | hashmap_map* m = (hashmap_map*) in;
330 |
331 | /* On empty hashmap, return immediately */
332 | if (hashmap_length(m) <= 0)
333 | return MAP_MISSING;
334 |
335 | /* Linear probing */
336 | for(i = 0; i< m->table_size; i++)
337 | if(m->data[i].in_use != 0) {
338 | any_t data = (any_t) (m->data[i].data);
339 | int status = f(item, data);
340 | if (status != MAP_OK) {
341 | return status;
342 | }
343 | }
344 |
345 | return MAP_OK;
346 | }
347 |
348 | /*
349 | * Remove an element with that key from the map
350 | */
351 | int hashmap_remove(map_t in, char* key){
352 | int i;
353 | int curr;
354 | hashmap_map* m;
355 |
356 | /* Cast the hashmap */
357 | m = (hashmap_map *) in;
358 |
359 | /* Find key */
360 | curr = hashmap_hash_int(m, key);
361 |
362 | /* Linear probing, if necessary */
363 | for(i = 0; idata[curr].in_use;
366 | if (in_use == 1){
367 | if (strcmp(m->data[curr].key,key)==0){
368 | /* Blank out the fields */
369 | m->data[curr].in_use = 0;
370 | m->data[curr].data = NULL;
371 | m->data[curr].key = NULL;
372 |
373 | /* Reduce the size */
374 | m->size--;
375 | return MAP_OK;
376 | }
377 | }
378 | curr = (curr + 1) % m->table_size;
379 | }
380 |
381 | /* Data not found */
382 | return MAP_MISSING;
383 | }
384 |
385 | /* Deallocate the hashmap */
386 | void hashmap_free(map_t in){
387 | hashmap_map* m = (hashmap_map*) in;
388 | free(m->data);
389 | free(m);
390 | }
391 |
392 | /* Return the length of the hashmap */
393 | int hashmap_length(map_t in){
394 | hashmap_map* m = (hashmap_map *) in;
395 | if(m != NULL) return m->size;
396 | else return 0;
397 | }
--------------------------------------------------------------------------------
/third_party/c_hashmap/hashmap.h:
--------------------------------------------------------------------------------
1 | /*
2 | * Generic hashmap manipulation functions
3 | *
4 | * Originally by Elliot C Back - http://elliottback.com/wp/hashmap-implementation-in-c/
5 | *
6 | * Modified by Pete Warden to fix a serious performance problem, support strings as keys
7 | * and removed thread synchronization - http://petewarden.typepad.com
8 | */
9 | #ifndef __HASHMAP_H__
10 | #define __HASHMAP_H__
11 |
12 | #define MAP_MISSING -3 /* No such element */
13 | #define MAP_FULL -2 /* Hashmap is full */
14 | #define MAP_OMEM -1 /* Out of Memory */
15 | #define MAP_OK 0 /* OK */
16 |
17 | /*
18 | * any_t is a pointer. This allows you to put arbitrary structures in
19 | * the hashmap.
20 | */
21 | typedef void *any_t;
22 |
23 | /*
24 | * PFany is a pointer to a function that can take two any_t arguments
25 | * and return an integer. Returns status code..
26 | */
27 | typedef int (*PFany)(any_t, any_t);
28 |
29 | /*
30 | * map_t is a pointer to an internally maintained data structure.
31 | * Clients of this package do not need to know how hashmaps are
32 | * represented. They see and manipulate only map_t's.
33 | */
34 | typedef any_t map_t;
35 |
36 | /*
37 | * Return an empty hashmap. Returns NULL if empty.
38 | */
39 | extern map_t hashmap_new();
40 |
41 | /*
42 | * Iteratively call f with argument (item, data) for
43 | * each element data in the hashmap. The function must
44 | * return a map status code. If it returns anything other
45 | * than MAP_OK the traversal is terminated. f must
46 | * not reenter any hashmap functions, or deadlock may arise.
47 | */
48 | extern int hashmap_iterate(map_t in, PFany f, any_t item);
49 |
50 | /*
51 | * Add an element to the hashmap. Return MAP_OK or MAP_OMEM.
52 | */
53 | extern int hashmap_put(map_t in, char* key, any_t value);
54 |
55 | /*
56 | * Get an element from the hashmap. Return MAP_OK or MAP_MISSING.
57 | */
58 | extern int hashmap_get(map_t in, char* key, any_t *arg);
59 |
60 | /*
61 | * Remove an element from the hashmap. Return MAP_OK or MAP_MISSING.
62 | */
63 | extern int hashmap_remove(map_t in, char* key);
64 |
65 | /*
66 | * Get any element. Return MAP_OK or MAP_MISSING.
67 | * remove - should the element be removed from the hashmap
68 | */
69 | extern int hashmap_get_one(map_t in, any_t *arg, int remove);
70 |
71 | /*
72 | * Free the hashmap
73 | */
74 | extern void hashmap_free(map_t in);
75 |
76 | /*
77 | * Get the current size of a hashmap
78 | */
79 | extern int hashmap_length(map_t in);
80 |
81 | #endif /* __HASHMAP_H__ */
--------------------------------------------------------------------------------
/third_party/c_hashmap/main.c:
--------------------------------------------------------------------------------
1 | /*
2 | * A unit test and example of how to use the simple C hashmap
3 | */
4 |
5 | #include
6 | #include
7 | #include
8 |
9 | #include "hashmap.h"
10 |
11 | #define KEY_MAX_LENGTH (256)
12 | #define KEY_PREFIX ("somekey")
13 | #define KEY_COUNT (1024*1024)
14 |
15 | typedef struct data_struct_s
16 | {
17 | char key_string[KEY_MAX_LENGTH];
18 | int number;
19 | } data_struct_t;
20 |
21 | int main(char* argv, int argc)
22 | {
23 | int index;
24 | int error;
25 | map_t mymap;
26 | char key_string[KEY_MAX_LENGTH];
27 | data_struct_t* value;
28 |
29 | mymap = hashmap_new();
30 |
31 | /* First, populate the hash map with ascending values */
32 | for (index=0; indexkey_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, index);
37 | value->number = index;
38 |
39 | error = hashmap_put(mymap, value->key_string, value);
40 | assert(error==MAP_OK);
41 | }
42 |
43 | /* Now, check all of the expected values are there */
44 | for (index=0; indexnumber==index);
53 | }
54 |
55 | /* Make sure that a value that wasn't in the map can't be found */
56 | snprintf(key_string, KEY_MAX_LENGTH, "%s%d", KEY_PREFIX, KEY_COUNT);
57 |
58 | error = hashmap_get(mymap, key_string, (void**)(&value));
59 |
60 | /* Make sure the value was not found */
61 | assert(error==MAP_MISSING);
62 |
63 | /* Free all of the values we allocated and remove them from the map */
64 | for (index=0; index> (64 - k));
13 | }
14 |
15 | void rng_init(rng *r, uint64_t seed1, uint64_t seed2)
16 | {
17 | r->state[0] = seed1;
18 | r->state[1] = seed2;
19 | }
20 |
21 | inline uint64_t rng_next(rng *r)
22 | {
23 | const uint64_t s0 = r->state[0];
24 | uint64_t s1 = r->state[1];
25 | const uint64_t value = s0 + s1;
26 |
27 | s1 ^= s0;
28 | r->state[0] = rotl(s0, 55) ^ s1 ^ (s1 << 14);
29 | r->state[1] = rotl(s1, 36);
30 |
31 | return value;
32 | }
33 |
34 | void rng_jump(rng *r)
35 | {
36 | static const uint64_t j[] = {0xbeac0467eba5facb, 0xd86b048b86aa9922};
37 |
38 | uint64_t s0 = 0, s1 = 0;
39 | for (int i = 0; i < 2; i++) {
40 | for (int b = 0; b < 64; b++) {
41 | if (j[i] & (uint64_t)1 << b) {
42 | s0 ^= r->state[0];
43 | s1 ^= r->state[1];
44 | }
45 | rng_next(r);
46 | }
47 | }
48 |
49 | r->state[0] = s0;
50 | r->state[1] = s1;
51 | }
52 |
53 |
--------------------------------------------------------------------------------
/util/rng.h:
--------------------------------------------------------------------------------
1 | /**
2 | * author: UncP
3 | * date: 2019-03-14
4 | * license: BSD-3
5 | **/
6 |
7 | #ifndef _rng_h_
8 | #define _rng_h_
9 |
10 | #include
11 |
12 | typedef struct rng
13 | {
14 | uint64_t state[2];
15 | }rng;
16 |
17 | void rng_init(rng *r, uint64_t seed1, uint64_t seed2);
18 | uint64_t rng_next(rng *r);
19 |
20 | #endif /* _rng_h_ */
21 |
--------------------------------------------------------------------------------