void testcorrectnessveb(){ int itr = 100000; int MAX = pow(2, 24); vebtree * vebt = veb_initialize(24, 64); binary_heap * bheap = bh_init_heap(MAX); FibHeap * fheap = fib_make_heap(); uint8_t * arr = calloc(MAX, sizeof(uint8_t)); int i; if (arr == NULL){ printf("dang... could not allocate enough memory\n"); exit(1); } bh_element * e; for (i = 0; i < itr; i++){ uint32_t s = random() % MAX; while(arr[s]) s = random() % MAX; arr[s] = 1; veb_insert(s, NULL, vebt); bh_insert(s, NULL, bheap); fib_insert(s, NULL, fheap); } uint32_t v, b, f; FibNode * fn; linked_list * llveb = veb_prio_walk(vebt); linked_list_node * nveb = llveb->first; for (i = 0; i < itr; i++){ v = vebt->min->value; veb_delete_min(vebt); e = bh_delete_min(bheap); b = e->key; free(e); fn = fib_find_min(fheap); f = fn->key; fib_delete_min(fheap); free(fn); if (b != v || b != f || v !=f || nveb->data != b){ printf("one of the datastructures was not correct\n"); printf("vEB: %d, bin: %d, fib: %d, veb walk: %d\n", v, b, f, nveb->data); exit(-1); } nveb = nveb->next; } printf("all data structures agree, so they can be assumed correct - %d -\n", bheap->size); free(arr); veb_destruct(vebt); bh_destruct(bheap); free(fheap); }
/* * bh_try_insert () - insert an element into the heap if heap hasn't reached * the full capacity or if new element is smaller than the * top element * return : old root element if it was replaced * heap (in) : heap * elem (in) : new element */ BH_ELEM bh_try_insert (BINARY_HEAP * heap, BH_ELEM elem) { if (heap->element_count < heap->max_capacity) { bh_insert (heap, elem); return NULL; } /* if root is larger than new element, replace root */ if (heap->cmp_func (heap->members[0], elem, heap->cmp_arg) == DB_GT) { return bh_replace_max (heap, elem); } return elem; }
void plot_rand_sort_bin(int num_vertices, int thres, FILE *gnuplot_ins, FILE *gnuplot_dm, FILE *gnuplot_total){ srandom(97643); printf("BinHeap: %d elements\n",num_vertices); int MAX = pow(2, 24); struct timespec delmin, ins, start, end; delmin.tv_nsec = 0; delmin.tv_sec = 0; ins.tv_nsec = 0; ins.tv_sec = 0; binary_heap * bheap = bh_init_heap(MAX); int i; uint8_t * arr = calloc(MAX, sizeof(uint8_t)); if (arr == NULL){ printf("dang...could not allocate enough memory\n"); exit(1); } bh_element *e; for (i = 0; i < num_vertices; i++){ uint32_t s = random() % MAX; while(arr[s]) s = random() % MAX; arr[s] = 1; clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); bh_insert(s, NULL, bheap); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); increment(&ins, &start, &end); } for (i = 0; i < num_vertices; i++){ clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); e= bh_delete_min(bheap); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); increment(&delmin, &start, &end); free(e); } free(arr); bh_destruct(bheap); if(gnuplot_ins) fprintf(gnuplot_ins, "%d %ld\n", num_vertices, ((ins.tv_sec* 1000000000)+(ins.tv_nsec))/num_vertices); if(gnuplot_dm) fprintf(gnuplot_dm, "%d %ld\n", num_vertices, ((delmin.tv_sec*1000000000)+(delmin.tv_nsec))/num_vertices); if(gnuplot_total) fprintf(gnuplot_total, "%d %ld\n", num_vertices, (((ins.tv_sec + delmin.tv_sec) * 1000)+(ins.tv_nsec + delmin.tv_nsec)/1000000)); }
void testcorrectnessvebpq(){ int itr = 100000; int MAX = pow(2, 24); vebtree * vebt = veb_pq_init(24); binary_heap * bheap = bh_init_heap(MAX); FibHeap * fheap = fib_make_heap(); int i; veb_pq_node * n; bh_element * e; for (i = 0; i < itr; i++){ uint32_t s = random() % MAX; veb_pq_node * n = malloc(sizeof(veb_pq_node)); n->node_prio = s; veb_pq_insert(n, vebt); bh_insert(s, NULL, bheap); fib_insert(s, NULL, fheap); } uint32_t v, b, f; FibNode * fn; for (i = 0; i < itr; i++){ v = vebt->min->value; n = veb_pq_deletemin(vebt);; free(n); e = bh_delete_min(bheap); b = e->key; free(e); fn = fib_find_min(fheap); f = fn->key; fib_delete_min(fheap); free(fn); if (b != v || b != f || v !=f){ printf("one of the datastructures was not correct\n"); printf("vEB: %d, bin: %d\n", v, b); exit(-1); } } printf("all data structures agree, so they can be assumed correct\n"); veb_destruct(vebt); bh_destruct(bheap); free(fheap); }
/* * NAME: fork->binh() * DESCRIPTION: copy a single fork for BinHex */ static int fork_binh(hfsfile *ifile, unsigned long size) { char buf[HFS_BLOCKSZ * 4]; long bytes; unsigned long total = 0; while (1) { bytes = hfs_read(ifile, buf, sizeof(buf)); if (bytes == -1) { ERROR(errno, hfs_error); return -1; } else if (bytes == 0) break; if (bh_insert(buf, bytes) == -1) { ERROR(errno, bh_error); return -1; } total += bytes; } if (total != size) { ERROR(EIO, "inconsistent fork length"); return -1; } if (bh_insertcrc() == -1) { ERROR(errno, bh_error); return -1; } return 0; }
/* * NAME: binhx() * DESCRIPTION: auxiliary BinHex routine */ static int binhx(hfsfile *ifile) { hfsdirent ent; unsigned char byte, word[2], lword[4]; if (hfs_fstat(ifile, &ent) == -1) { ERROR(errno, hfs_error); return -1; } byte = strlen(ent.name); if (bh_insert(&byte, 1) == -1 || bh_insert(ent.name, byte + 1) == -1 || bh_insert(ent.u.file.type, 4) == -1 || bh_insert(ent.u.file.creator, 4) == -1) { ERROR(errno, bh_error); return -1; } d_putsw(word, ent.fdflags); if (bh_insert(word, 2) == -1) { ERROR(errno, bh_error); return -1; } d_putul(lword, ent.u.file.dsize); if (bh_insert(lword, 4) == -1) { ERROR(errno, bh_error); return -1; } d_putul(lword, ent.u.file.rsize); if (bh_insert(lword, 4) == -1 || bh_insertcrc() == -1) { ERROR(errno, bh_error); return -1; } if (hfs_setfork(ifile, 0) == -1) { ERROR(errno, hfs_error); return -1; } if (fork_binh(ifile, ent.u.file.dsize) == -1) return -1; if (hfs_setfork(ifile, 1) == -1) { ERROR(errno, hfs_error); return -1; } if (fork_binh(ifile, ent.u.file.rsize) == -1) return -1; return 0; }
void plot_dkmax2_bin(uint32_t num_vertices, uint32_t source, FILE *gnuplot_ins, FILE *gnuplot_dm, FILE *gnuplot_total, FILE *gnuplot_dk){ printf("BinHeap: %d vertices\n",num_vertices); uint32_t **w2 = malloc(sizeof(uint32_t *)); uint32_t *weights; uint32_t **edges = generate_instance(num_vertices, w2); weights = *w2; struct timespec delmin, deck, ins, start, end; delmin.tv_nsec = 0; delmin.tv_sec = 0; deck.tv_nsec = 0; deck.tv_sec = 0; ins.tv_nsec = 0; ins.tv_sec = 0; binary_heap * heap = bh_init_heap(num_vertices); uint32_t *distances = malloc(num_vertices * sizeof(uint32_t)); bh_element ** vertices = malloc(num_vertices * sizeof(bh_element *)); uint32_t distance; uint32_t *data; uint32_t i; for (i = 0; i < num_vertices; i++) { if(i == source) distance = 0; else distance = UINT_MAX; distances[i] = distance; data = malloc(sizeof(uint32_t)); *data = i; clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); vertices[i] = bh_insert(distance, data, heap); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); increment(&ins, &start, &end); } bh_element *node; uint32_t decrease_key_calls = 0; clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); node = bh_delete_min(heap); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); increment(&delmin, &start, &end); while (node) { uint32_t u = *((uint32_t *)node->data); for (i = 1; i <= edges[u][0]; i++) { uint32_t v = edges[u][i]; uint32_t alt = distances[u] + weights[u * num_vertices + v]; if (alt < distances[v]) { clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); bh_decrease_key(distances[v] - alt, vertices[v], heap); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); increment(&deck, &start, &end); distances[v] = alt; decrease_key_calls++; } } free(node->data); free(node); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start); node = bh_delete_min(heap); clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &end); increment(&delmin, &start, &end); } for (i = 0; i < num_vertices; i++) free(edges[i]); free(edges); bh_destruct(heap); free(vertices); free(distances); free(w2); free(weights); if(gnuplot_ins) fprintf(gnuplot_ins, "%d %ld\n", num_vertices, ((ins.tv_sec* 1000000000)+(ins.tv_nsec))/num_vertices); if(gnuplot_dm) fprintf(gnuplot_dm, "%d %ld\n", num_vertices, ((delmin.tv_sec*1000000000)+(delmin.tv_nsec))/num_vertices); if(gnuplot_dk) fprintf(gnuplot_dk, "%d %ld\n", num_vertices, ((deck.tv_sec* 1000000000)+(deck.tv_nsec))/decrease_key_calls); if(gnuplot_total) fprintf(gnuplot_total, "%d %ld\n", num_vertices, (((ins.tv_sec + delmin.tv_sec + deck.tv_sec) * 1000)+(ins.tv_nsec + delmin.tv_nsec + deck.tv_nsec)/1000000)); }
void time_bin_dijkstra(uint32_t num_vertices, uint32_t source, uint32_t * weights, uint32_t ** edges){ clock_t start, end; double binit = 0; double bdm = 0; double bdk = 0; double bins = 0; start = clock(); binary_heap * heap = bh_init_heap(num_vertices); end = clock(); binit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; uint32_t *distances = malloc(num_vertices * sizeof(uint32_t)); bh_element ** vertices = malloc(num_vertices * sizeof(bh_element *)); uint32_t distance; uint32_t *data; uint32_t i; for (i = 0; i < num_vertices; i++) { if(i == source) distance = 0; else distance = UINT_MAX; distances[i] = distance; data = malloc(sizeof(uint32_t)); *data = i; start = clock(); vertices[i] = bh_insert(distance, data, heap); end = clock(); bins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; } bh_element *node; uint32_t decrease_key_calls = 0; start = clock(); node = bh_delete_min(heap); end = clock(); bdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; while (node) { uint32_t u = *((uint32_t *)node->data); for (i = 1; i <= edges[u][0]; i++) { uint32_t v = edges[u][i]; uint32_t alt = distances[u] + weights[u * num_vertices + v]; if (alt < distances[v]) { start = clock(); bh_decrease_key(distances[v] - alt, vertices[v], heap); end = clock(); bdk += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; distances[v] = alt; decrease_key_calls++; } } free(node->data); free(node); start = clock(); node = bh_delete_min(heap); end = clock(); bdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; } bh_destruct(heap); free(vertices); free(distances); printf("bin: init: %f - total time: %f\n", binit, binit+bdm+bins+bdk); printf(" insert: %f (avg: %f)\n", bins, bins/num_vertices); printf(" delmin: %f (avg: %f)\n", bdm, bdm/num_vertices); printf(" dec.ke: %f (avg: %f)\n\n", bdk, bdk/decrease_key_calls); }
void testVEBperformance_random_sort(int itr, int thres){ int MAX = pow(2, 24); double vinit, binit, finit, vins, bins, fins, vdm, bdm, fdm; finit = 0; fdm = 0; clock_t start = clock(); vebtree * vebt = veb_initialize(24, thres); clock_t end = clock(); vinit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); binary_heap * bheap = bh_init_heap(MAX); end = clock(); binit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; FibHeap * fheap = NULL; if (itr < 1500000){ start = clock(); fheap = fib_make_heap(); end = clock(); finit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; } printf("vEB init: %f ms - bhinit: %f ms - fibinit: %f ms\n", vinit, binit, finit); int i; uint8_t * arr = calloc(MAX, sizeof(uint8_t)); if (arr == NULL){ printf("dang...could not allocate enough memory\n"); exit(1); } vins = 0; bins = 0; fins = 0; vdm = 0; bdm = 0; fdm = 0; bh_element *e; FibNode * fn; for (i = 0; i < itr; i++){ uint32_t s = random() % MAX; while(arr[s]) s = random() % MAX; arr[s] = 1; start = clock(); veb_insert(s, NULL, vebt); end = clock(); vins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); bh_insert(s, NULL, bheap); end = clock(); bins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; if (itr < 1500000){ start = clock(); fib_insert(s, NULL, fheap); end = clock(); fins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; } } printf("spend time inserting: vEB: %f ms (avg %f) - BH: %f ms (avg %f) - fib: %f ms (avg %f)\n", vins, vins/itr, bins, bins/itr, fins, fins/itr); //printf("avg: vEB %f ms - BH: %f ms\n", vins/itr, bins/itr); uint32_t v, b, f; for (i = 0; i < itr; i++){ start = clock(); v = vebt->min->value; veb_delete_min(vebt); end = clock(); vdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); e= bh_delete_min(bheap); end = clock(); b = e->key; free(e); bdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; fn = fib_find_min(fheap); f = fn->key; if (itr < 1500000){ start = clock(); fib_delete_min(fheap); end = clock(); fdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; free(fn); } } printf("spend time deletemin: vEB: %f ms (avg %f) - BH: %f ms (avg %f)", vdm, vdm/itr, bdm, bdm/itr); if (itr < 1500000) printf(" - fib: %f ms (avg %f)\n", fdm, fdm/itr); else printf("\n"); free(arr); veb_destruct(vebt); bh_destruct(bheap); if (itr < 1500000) free(fheap); }
void testPQperformance_random(int itr){ int MAX = pow(2, 24); double vinit, binit, finit, vins, bins, fins, vdm, bdm, fdm; clock_t start = clock(); vebtree * vebt = veb_pq_init(24); clock_t end = clock(); vinit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); binary_heap * bheap = bh_init_heap(itr); end = clock(); binit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); FibHeap * fheap = fib_make_heap(); end = clock(); finit = ((double) (end-start) / CLOCKS_PER_SEC) * 1000; printf("vEB init: %f ms - bhinit: %f ms - fibinit: %f ms\n", vinit, binit, finit); int i; vins = 0; bins = 0; fins = 0; vdm = 0; bdm = 0; fdm = 0; veb_pq_node * n; bh_element * e; FibNode * fn; for (i = 0; i < itr; i++){ uint32_t s = random() % MAX; veb_pq_node * n = malloc(sizeof(veb_pq_node)); n->node_prio = s; n->node_nr = i; start = clock(); veb_pq_insert(n, vebt); end = clock(); vins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); bh_insert(s, NULL, bheap); end = clock(); bins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); fib_insert(s, NULL, fheap); end = clock(); fins += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; } printf("spend time inserting: vEB: %f ms (avg %f) - BH: %f ms (avg %f) - fib: %f ms (avg %f)\n", vins, vins/itr, bins, bins/itr, fins, fins/itr); //printf("avg: vEB %f ms - BH: %f ms\n", vins/itr, bins/itr); uint32_t v, b, f; for (i = 0; i < itr; i++){ v = vebt->min->value; start = clock(); n = veb_pq_deletemin(vebt);; end = clock(); free(n); vdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; start = clock(); e = bh_delete_min(bheap); end = clock(); b = e->key; free(e); bdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; fn = fib_find_min(fheap); f = fn->key; start = clock(); fib_delete_min(fheap); end = clock(); fdm += ((double) (end-start) / CLOCKS_PER_SEC) * 1000; free(fn); if (b != v || b != f || v != f){ printf("vEB: %d, bin: %d\n", v, b); exit(-1); } } printf("spend time deletemin: vEB: %f ms (avg %f) - BH: %f ms (avg %f) - fib: %f ms (avg %f)\n", vdm, vdm/itr, bdm, bdm/itr, fdm, fdm/itr); //printf("avg: vEB %f ms - BH: %f ms\n", vdm/itr, bdm/itr); veb_destruct(vebt); bh_destruct(bheap); free(fheap); }