diff --git a/src/bmz.c b/src/bmz.c index b06e0c4..7b29a86 100644 --- a/src/bmz.c +++ b/src/bmz.c @@ -1,8 +1,10 @@ +#include "graph.h" #include "bmz.h" #include "cmph_structs.h" #include "bmz_structs.h" #include "hash.h" #include "vqueue.h" +#include "bitbool.h" #include #include @@ -15,49 +17,39 @@ //static cmph_uint32 UNDEFINED = UINT_MAX; -static const char bitmask[8] = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 }; -#define GETBIT(array, i) (array[(i) / 8] & bitmask[(i) % 8]) -#define SETBIT(array, i) (array[(i) / 8] |= bitmask[(i) % 8]) -#define UNSETBIT(array, i) (array[(i) / 8] &= (~(bitmask[(i) % 8]))) +/* static const char bitmask[8] = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 }; */ +/* #define GETBIT(array, i) (array[(i) / 8] & bitmask[(i) % 8]) */ +/* #define SETBIT(array, i) (array[(i) / 8] |= bitmask[(i) % 8]) */ +/* #define UNSETBIT(array, i) (array[(i) / 8] &= (~(bitmask[(i) % 8]))) */ -static int bmz_gen_edges(cmph_mph_t *mph); -static cmph_uint8 bmz_traverse_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited); -static cmph_uint8 bmz_traverse_critical_nodes_heuristic(cmph_bmz_mph_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited); -static void bmz_traverse_non_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uint8 * used_edges, cmph_uint8 * visited); +static int bmz_gen_edges(cmph_config_t *mph); +static cmph_uint8 bmz_traverse_critical_nodes(bmz_config_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited); +static cmph_uint8 bmz_traverse_critical_nodes_heuristic(bmz_config_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited); +static void bmz_traverse_non_critical_nodes(bmz_config_data_t *bmz, cmph_uint8 * used_edges, cmph_uint8 * visited); - -cmph_mph_t *cmph_bmz_mph_new(cmph_key_source_t *key_source) +bmz_config_data_t *bmz_config_new(cmph_key_source_t *key_source) { - cmph_mph_t *mph = NULL; - cmph_bmz_mph_data_t *bmz = NULL; - mph = cmph__mph_new(CMPH_BMZ, key_source); - if (mph == NULL) return NULL; - bmz = (cmph_bmz_mph_data_t *)malloc(sizeof(cmph_bmz_mph_data_t)); - if (bmz == NULL) - { - cmph__mph_destroy(mph); - return NULL; - } + bmz_config_data_t *bmz = NULL; + bmz = (bmz_config_data_t *)malloc(sizeof(bmz_config_data_t)); bmz->hashfuncs[0] = CMPH_HASH_JENKINS; bmz->hashfuncs[1] = CMPH_HASH_JENKINS; bmz->g = NULL; bmz->graph = NULL; bmz->hashes = NULL; - mph->data = bmz; - assert(mph->data); - return mph; -} -void cmph_bmz_mph_destroy(cmph_mph_t *mph) -{ - cmph_bmz_mph_data_t *data = (cmph_bmz_mph_data_t *)mph->data; - DEBUGP("Destroying algorithm dependent data\n"); - free(data); - cmph__mph_destroy(mph); + assert(bmz); + return bmz; } -void cmph_bmz_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs) +void bmz_config_destroy(cmph_config_t *mph) { - cmph_bmz_mph_data_t *bmz = (cmph_bmz_mph_data_t *)mph->data; + bmz_config_data_t *data = (bmz_config_data_t *)mph->data; + DEBUGP("Destroying algorithm dependent data\n"); + free(data); +} + +void bmz_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs) +{ + bmz_config_data_t *bmz = (bmz_config_data_t *)mph->data; CMPH_HASH *hashptr = hashfuncs; cmph_uint32 i = 0; while(*hashptr != CMPH_HASH_COUNT) @@ -68,10 +60,10 @@ void cmph_bmz_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs) } } -cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) +cmph_t *bmz_new(cmph_config_t *mph, float c) { - cmph_mphf_t *mphf = NULL; - cmph_bmz_mphf_data_t *bmzf = NULL; + cmph_t *mphf = NULL; + bmz_data_t *bmzf = NULL; cmph_uint32 i; cmph_uint32 iterations; cmph_uint32 iterations_map = 20; @@ -79,15 +71,15 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) cmph_uint8 restart_mapping = 0; cmph_uint8 * visited = NULL; - DEBUGP("bmz_c: %f\n", bmz_c); - cmph_bmz_mph_data_t *bmz = (cmph_bmz_mph_data_t *)mph->data; + DEBUGP("c: %f\n", c); + bmz_config_data_t *bmz = (bmz_config_data_t *)mph->data; bmz->m = mph->key_source->nkeys; - bmz->n = ceil(bmz_c * mph->key_source->nkeys); - DEBUGP("m (edges): %u n (vertices): %u bmz_c: %f\n", bmz->m, bmz->n, bmz_c); - bmz->graph = cmph_graph_new(bmz->n, bmz->m); + bmz->n = ceil(c * mph->key_source->nkeys); + DEBUGP("m (edges): %u n (vertices): %u c: %f\n", bmz->m, bmz->n, c); + bmz->graph = graph_new(bmz->n, bmz->m); DEBUGP("Created graph\n"); - bmz->hashes = (cmph_hash_state_t **)malloc(sizeof(cmph_hash_state_t *)*3); + bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*3); for(i = 0; i < 3; ++i) bmz->hashes[i] = NULL; do @@ -104,17 +96,17 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) { int ok; DEBUGP("hash function 1\n"); - bmz->hashes[0] = cmph_hash_state_new(bmz->hashfuncs[0], bmz->n); + bmz->hashes[0] = hash_state_new(bmz->hashfuncs[0], bmz->n); DEBUGP("hash function 2\n"); - bmz->hashes[1] = cmph_hash_state_new(bmz->hashfuncs[1], bmz->n); + bmz->hashes[1] = hash_state_new(bmz->hashfuncs[1], bmz->n); DEBUGP("Generating edges\n"); ok = bmz_gen_edges(mph); if (!ok) { --iterations; - cmph_hash_state_destroy(bmz->hashes[0]); + hash_state_destroy(bmz->hashes[0]); bmz->hashes[0] = NULL; - cmph_hash_state_destroy(bmz->hashes[1]); + hash_state_destroy(bmz->hashes[1]); bmz->hashes[1] = NULL; DEBUGP("%u iterations remaining\n", iterations); if (mph->verbosity) @@ -127,7 +119,7 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) } if (iterations == 0) { - cmph_graph_destroy(bmz->graph); + graph_destroy(bmz->graph); return NULL; } @@ -137,7 +129,7 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) fprintf(stderr, "Starting ordering step\n"); } - cmph_graph_obtain_critical_nodes(bmz->graph); + graph_obtain_critical_nodes(bmz->graph); // Searching step if (mph->verbosity) @@ -155,9 +147,9 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) assert(bmz->g); for (i = 0; i < bmz->n; ++i) // critical nodes { - if (cmph_graph_node_is_critical(bmz->graph, i) && (!GETBIT(visited,i))) + if (graph_node_is_critical(bmz->graph, i) && (!GETBIT(visited,i))) { - if(bmz_c > 1.14) restart_mapping = bmz_traverse_critical_nodes(bmz, i, &biggest_g_value, &biggest_edge_value, used_edges, visited); + if(c > 1.14) restart_mapping = bmz_traverse_critical_nodes(bmz, i, &biggest_g_value, &biggest_edge_value, used_edges, visited); else restart_mapping = bmz_traverse_critical_nodes_heuristic(bmz, i, &biggest_g_value, &biggest_edge_value, used_edges, visited); if(restart_mapping) break; } @@ -178,12 +170,12 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) free(used_edges); free(visited); }while(restart_mapping && iterations_map > 0); - cmph_graph_destroy(bmz->graph); + graph_destroy(bmz->graph); bmz->graph = NULL; if (iterations_map == 0) return NULL; - mphf = (cmph_mphf_t *)malloc(sizeof(cmph_mphf_t)); + mphf = (cmph_t *)malloc(sizeof(cmph_t)); mphf->algo = mph->algo; - bmzf = (cmph_bmz_mphf_data_t *)malloc(sizeof(cmph_bmz_mph_data_t)); + bmzf = (bmz_data_t *)malloc(sizeof(bmz_config_data_t)); bmzf->g = bmz->g; bmz->g = NULL; //transfer memory ownership bmzf->hashes = bmz->hashes; @@ -200,41 +192,41 @@ cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c) return mphf; } -static cmph_uint8 bmz_traverse_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited) +static cmph_uint8 bmz_traverse_critical_nodes(bmz_config_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited) { cmph_uint32 next_g; cmph_uint32 u; /* Auxiliary vertex */ cmph_uint32 lav; /* lookahead vertex */ cmph_uint8 collision; - cmph_vqueue_t * q = cmph_vqueue_new((cmph_uint32)(0.5*cmph_graph_ncritical_nodes(bmz->graph)) + 1); - cmph_graph_iterator_t it, it1; + vqueue_t * q = vqueue_new((cmph_uint32)(0.5*graph_ncritical_nodes(bmz->graph)) + 1); + graph_iterator_t it, it1; DEBUGP("Labelling critical vertices\n"); bmz->g[v] = (cmph_uint32)ceil ((double)(*biggest_edge_value)/2) - 1; SETBIT(visited, v); next_g = (cmph_uint32)floor((double)(*biggest_edge_value/2)); /* next_g is incremented in the do..while statement*/ - cmph_vqueue_insert(q, v); - while(!cmph_vqueue_is_empty(q)) + vqueue_insert(q, v); + while(!vqueue_is_empty(q)) { - v = cmph_vqueue_remove(q); - it = cmph_graph_neighbors_it(bmz->graph, v); - while ((u = cmph_graph_next_neighbor(bmz->graph, &it)) != CMPH_GRAPH_NO_NEIGHBOR) + v = vqueue_remove(q); + it = graph_neighbors_it(bmz->graph, v); + while ((u = graph_next_neighbor(bmz->graph, &it)) != GRAPH_NO_NEIGHBOR) { - if (cmph_graph_node_is_critical(bmz->graph, u) && (!GETBIT(visited,u))) + if (graph_node_is_critical(bmz->graph, u) && (!GETBIT(visited,u))) { collision = 1; while(collision) // lookahead to resolve collisions { next_g = *biggest_g_value + 1; - it1 = cmph_graph_neighbors_it(bmz->graph, u); + it1 = graph_neighbors_it(bmz->graph, u); collision = 0; - while((lav = cmph_graph_next_neighbor(bmz->graph, &it1)) != CMPH_GRAPH_NO_NEIGHBOR) + while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { - if (cmph_graph_node_is_critical(bmz->graph, lav) && GETBIT(visited,lav)) + if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited,lav)) { if(next_g + bmz->g[lav] >= bmz->m) { - cmph_vqueue_destroy(q); + vqueue_destroy(q); return 1; // restart mapping step. } if (GETBIT(used_edges, next_g + bmz->g[lav])) @@ -247,10 +239,10 @@ static cmph_uint8 bmz_traverse_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uin if (next_g > *biggest_g_value) *biggest_g_value = next_g; } // Marking used edges... - it1 = cmph_graph_neighbors_it(bmz->graph, u); - while((lav = cmph_graph_next_neighbor(bmz->graph, &it1)) != CMPH_GRAPH_NO_NEIGHBOR) + it1 = graph_neighbors_it(bmz->graph, u); + while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { - if (cmph_graph_node_is_critical(bmz->graph, lav) && GETBIT(visited, lav)) + if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited, lav)) { SETBIT(used_edges,next_g + bmz->g[lav]); if(next_g + bmz->g[lav] > *biggest_edge_value) *biggest_edge_value = next_g + bmz->g[lav]; @@ -258,16 +250,16 @@ static cmph_uint8 bmz_traverse_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uin } bmz->g[u] = next_g; // Labelling vertex u. SETBIT(visited,u); - cmph_vqueue_insert(q, u); + vqueue_insert(q, u); } } } - cmph_vqueue_destroy(q); + vqueue_destroy(q); return 0; } -static cmph_uint8 bmz_traverse_critical_nodes_heuristic(cmph_bmz_mph_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited) +static cmph_uint8 bmz_traverse_critical_nodes_heuristic(bmz_config_data_t *bmz, cmph_uint32 v, cmph_uint32 * biggest_g_value, cmph_uint32 * biggest_edge_value, cmph_uint8 * used_edges, cmph_uint8 * visited) { cmph_uint32 next_g; cmph_uint32 u; /* Auxiliary vertex */ @@ -276,21 +268,21 @@ static cmph_uint8 bmz_traverse_critical_nodes_heuristic(cmph_bmz_mph_data_t *bmz cmph_uint32 * unused_g_values = NULL; cmph_uint32 unused_g_values_capacity = 0; cmph_uint32 nunused_g_values = 0; - cmph_vqueue_t * q = cmph_vqueue_new((cmph_uint32)(0.5*cmph_graph_ncritical_nodes(bmz->graph))+1); - cmph_graph_iterator_t it, it1; + vqueue_t * q = vqueue_new((cmph_uint32)(0.5*graph_ncritical_nodes(bmz->graph))+1); + graph_iterator_t it, it1; DEBUGP("Labelling critical vertices\n"); bmz->g[v] = (cmph_uint32)ceil ((double)(*biggest_edge_value)/2) - 1; SETBIT(visited, v); next_g = (cmph_uint32)floor((double)(*biggest_edge_value/2)); /* next_g is incremented in the do..while statement*/ - cmph_vqueue_insert(q, v); - while(!cmph_vqueue_is_empty(q)) + vqueue_insert(q, v); + while(!vqueue_is_empty(q)) { - v = cmph_vqueue_remove(q); - it = cmph_graph_neighbors_it(bmz->graph, v); - while ((u = cmph_graph_next_neighbor(bmz->graph, &it)) != CMPH_GRAPH_NO_NEIGHBOR) + v = vqueue_remove(q); + it = graph_neighbors_it(bmz->graph, v); + while ((u = graph_next_neighbor(bmz->graph, &it)) != GRAPH_NO_NEIGHBOR) { - if (cmph_graph_node_is_critical(bmz->graph, u) && (!GETBIT(visited,u))) + if (graph_node_is_critical(bmz->graph, u) && (!GETBIT(visited,u))) { cmph_uint32 next_g_index = 0; collision = 1; @@ -305,15 +297,15 @@ static cmph_uint8 bmz_traverse_critical_nodes_heuristic(cmph_bmz_mph_data_t *bmz next_g = *biggest_g_value + 1; next_g_index = UINT_MAX; } - it1 = cmph_graph_neighbors_it(bmz->graph, u); + it1 = graph_neighbors_it(bmz->graph, u); collision = 0; - while((lav = cmph_graph_next_neighbor(bmz->graph, &it1)) != CMPH_GRAPH_NO_NEIGHBOR) + while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { - if (cmph_graph_node_is_critical(bmz->graph, lav) && GETBIT(visited,lav)) + if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited,lav)) { if(next_g + bmz->g[lav] >= bmz->m) { - cmph_vqueue_destroy(q); + vqueue_destroy(q); free(unused_g_values); return 1; // restart mapping step. } @@ -340,10 +332,10 @@ static cmph_uint8 bmz_traverse_critical_nodes_heuristic(cmph_bmz_mph_data_t *bmz if (next_g_index < nunused_g_values) unused_g_values[next_g_index] = unused_g_values[--nunused_g_values]; // Marking used edges... - it1 = cmph_graph_neighbors_it(bmz->graph, u); - while((lav = cmph_graph_next_neighbor(bmz->graph, &it1)) != CMPH_GRAPH_NO_NEIGHBOR) + it1 = graph_neighbors_it(bmz->graph, u); + while((lav = graph_next_neighbor(bmz->graph, &it1)) != GRAPH_NO_NEIGHBOR) { - if (cmph_graph_node_is_critical(bmz->graph, lav) && GETBIT(visited, lav)) + if (graph_node_is_critical(bmz->graph, lav) && GETBIT(visited, lav)) { SETBIT(used_edges,next_g + bmz->g[lav]); if(next_g + bmz->g[lav] > *biggest_edge_value) *biggest_edge_value = next_g + bmz->g[lav]; @@ -351,17 +343,17 @@ static cmph_uint8 bmz_traverse_critical_nodes_heuristic(cmph_bmz_mph_data_t *bmz } bmz->g[u] = next_g; // Labelling vertex u. SETBIT(visited, u); - cmph_vqueue_insert(q, u); + vqueue_insert(q, u); } } } - cmph_vqueue_destroy(q); + vqueue_destroy(q); free(unused_g_values); return 0; } -static cmph_uint32 next_unused_edge(cmph_bmz_mph_data_t *bmz, cmph_uint8 * used_edges, cmph_uint32 unused_edge_index) +static cmph_uint32 next_unused_edge(bmz_config_data_t *bmz, cmph_uint8 * used_edges, cmph_uint32 unused_edge_index) { while(1) { @@ -372,11 +364,11 @@ static cmph_uint32 next_unused_edge(cmph_bmz_mph_data_t *bmz, cmph_uint8 * used_ return unused_edge_index; } -static void bmz_traverse(cmph_bmz_mph_data_t *bmz, cmph_uint8 * used_edges, cmph_uint32 v, cmph_uint32 * unused_edge_index, cmph_uint8 * visited) +static void bmz_traverse(bmz_config_data_t *bmz, cmph_uint8 * used_edges, cmph_uint32 v, cmph_uint32 * unused_edge_index, cmph_uint8 * visited) { - cmph_graph_iterator_t it = cmph_graph_neighbors_it(bmz->graph, v); + graph_iterator_t it = graph_neighbors_it(bmz->graph, v); cmph_uint32 neighbor = 0; - while((neighbor = cmph_graph_next_neighbor(bmz->graph, &it)) != CMPH_GRAPH_NO_NEIGHBOR) + while((neighbor = graph_next_neighbor(bmz->graph, &it)) != GRAPH_NO_NEIGHBOR) { if(GETBIT(visited,neighbor)) continue; DEBUGP("Visiting neighbor %u\n", neighbor); @@ -389,15 +381,15 @@ static void bmz_traverse(cmph_bmz_mph_data_t *bmz, cmph_uint8 * used_edges, cmph } } -static void bmz_traverse_non_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uint8 * used_edges, cmph_uint8 * visited) +static void bmz_traverse_non_critical_nodes(bmz_config_data_t *bmz, cmph_uint8 * used_edges, cmph_uint8 * visited) { cmph_uint32 i, v1, v2, unused_edge_index = 0; DEBUGP("Labelling non critical vertices\n"); for(i = 0; i < bmz->m; i++) { - v1 = cmph_graph_vertex_id(bmz->graph, i, 0); - v2 = cmph_graph_vertex_id(bmz->graph, i, 1); + v1 = graph_vertex_id(bmz->graph, i, 0); + v2 = graph_vertex_id(bmz->graph, i, 1); if((GETBIT(visited,v1) && GETBIT(visited,v2)) || (!GETBIT(visited,v1) && !GETBIT(visited,v2))) continue; if(GETBIT(visited,v1)) bmz_traverse(bmz, used_edges, v1, &unused_edge_index, visited); else bmz_traverse(bmz, used_edges, v2, &unused_edge_index, visited); @@ -416,14 +408,14 @@ static void bmz_traverse_non_critical_nodes(cmph_bmz_mph_data_t *bmz, cmph_uint8 } -static int bmz_gen_edges(cmph_mph_t *mph) +static int bmz_gen_edges(cmph_config_t *mph) { cmph_uint32 e; - cmph_bmz_mph_data_t *bmz = (cmph_bmz_mph_data_t *)mph->data; + bmz_config_data_t *bmz = (bmz_config_data_t *)mph->data; cmph_uint8 multiple_edges = 0; DEBUGP("Generating edges for %u vertices\n", bmz->n); - cmph_graph_clear_edges(bmz->graph); + graph_clear_edges(bmz->graph); mph->key_source->rewind(mph->key_source->data); for (e = 0; e < mph->key_source->nkeys; ++e) { @@ -431,8 +423,8 @@ static int bmz_gen_edges(cmph_mph_t *mph) cmph_uint32 keylen; char *key; mph->key_source->read(mph->key_source->data, &key, &keylen); - h1 = cmph_hash(bmz->hashes[0], key, keylen) % bmz->n; - h2 = cmph_hash(bmz->hashes[1], key, keylen) % bmz->n; + h1 = hash(bmz->hashes[0], key, keylen) % bmz->n; + h2 = hash(bmz->hashes[1], key, keylen) % bmz->n; if (h1 == h2) if (++h2 >= bmz->n) h2 = 0; if (h1 == h2) { @@ -442,34 +434,34 @@ static int bmz_gen_edges(cmph_mph_t *mph) } DEBUGP("Adding edge: %u -> %u for key %s\n", h1, h2, key); mph->key_source->dispose(mph->key_source->data, key, keylen); - multiple_edges = cmph_graph_contains_edge(bmz->graph, h1, h2); + multiple_edges = graph_contains_edge(bmz->graph, h1, h2); if (mph->verbosity && multiple_edges) fprintf(stderr, "A non simple graph was generated\n"); if (multiple_edges) return 0; // checking multiple edge restriction. - cmph_graph_add_edge(bmz->graph, h1, h2); + graph_add_edge(bmz->graph, h1, h2); } return !multiple_edges; } -int cmph_bmz_mphf_dump(cmph_mphf_t *mphf, FILE *fd) +int bmz_dump(cmph_t *mphf, FILE *fd) { char *buf = NULL; cmph_uint32 buflen; cmph_uint32 nbuflen; cmph_uint32 i; cmph_uint32 two = 2; //number of hash functions - cmph_bmz_mphf_data_t *data = (cmph_bmz_mphf_data_t *)mphf->data; + bmz_data_t *data = (bmz_data_t *)mphf->data; cmph_uint32 nn, nm; - cmph__mphf_dump(mphf, fd); + __cmph_dump(mphf, fd); fwrite(&two, sizeof(cmph_uint32), 1, fd); - cmph_hash_state_dump(data->hashes[0], &buf, &buflen); + hash_state_dump(data->hashes[0], &buf, &buflen); DEBUGP("Dumping hash state with %u bytes to disk\n", buflen); fwrite(&buflen, sizeof(cmph_uint32), 1, fd); fwrite(buf, buflen, 1, fd); free(buf); - cmph_hash_state_dump(data->hashes[1], &buf, &buflen); + hash_state_dump(data->hashes[1], &buf, &buflen); DEBUGP("Dumping hash state with %u bytes to disk\n", buflen); fwrite(&buflen, sizeof(cmph_uint32), 1, fd); fwrite(buf, buflen, 1, fd); @@ -487,28 +479,28 @@ int cmph_bmz_mphf_dump(cmph_mphf_t *mphf, FILE *fd) return 1; } -void cmph_bmz_mphf_load(FILE *f, cmph_mphf_t *mphf) +void bmz_load(FILE *f, cmph_t *mphf) { cmph_uint32 nhashes; char *buf = NULL; cmph_uint32 buflen; cmph_uint32 i; - cmph_bmz_mphf_data_t *bmz = (cmph_bmz_mphf_data_t *)malloc(sizeof(cmph_bmz_mphf_data_t)); + bmz_data_t *bmz = (bmz_data_t *)malloc(sizeof(bmz_data_t)); DEBUGP("Loading bmz mphf\n"); mphf->data = bmz; fread(&nhashes, sizeof(cmph_uint32), 1, f); - bmz->hashes = (cmph_hash_state_t **)malloc(sizeof(cmph_hash_state_t *)*(nhashes + 1)); + bmz->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1)); bmz->hashes[nhashes] = NULL; DEBUGP("Reading %u hashes\n", nhashes); for (i = 0; i < nhashes; ++i) { - cmph_hash_state_t *state = NULL; + hash_state_t *state = NULL; fread(&buflen, sizeof(cmph_uint32), 1, f); DEBUGP("Hash state has %u bytes\n", buflen); buf = (char *)malloc(buflen); fread(buf, buflen, 1, f); - state = cmph_hash_state_load(buf, buflen); + state = hash_state_load(buf, buflen); bmz->hashes[i] = state; free(buf); } @@ -528,22 +520,22 @@ void cmph_bmz_mphf_load(FILE *f, cmph_mphf_t *mphf) } -cmph_uint32 cmph_bmz_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 keylen) +cmph_uint32 bmz_search(cmph_t *mphf, const char *key, cmph_uint32 keylen) { - cmph_bmz_mphf_data_t *bmz = mphf->data; - cmph_uint32 h1 = cmph_hash(bmz->hashes[0], key, keylen) % bmz->n; - cmph_uint32 h2 = cmph_hash(bmz->hashes[1], key, keylen) % bmz->n; + bmz_data_t *bmz = mphf->data; + cmph_uint32 h1 = hash(bmz->hashes[0], key, keylen) % bmz->n; + cmph_uint32 h2 = hash(bmz->hashes[1], key, keylen) % bmz->n; DEBUGP("key: %s h1: %u h2: %u\n", key, h1, h2); if (h1 == h2 && ++h2 > bmz->n) h2 = 0; DEBUGP("key: %s g[h1]: %u g[h2]: %u edges: %u\n", key, bmz->g[h1], bmz->g[h2], bmz->m); return bmz->g[h1] + bmz->g[h2]; } -void cmph_bmz_mphf_destroy(cmph_mphf_t *mphf) +void bmz_destroy(cmph_t *mphf) { - cmph_bmz_mphf_data_t *data = (cmph_bmz_mphf_data_t *)mphf->data; + bmz_data_t *data = (bmz_data_t *)mphf->data; free(data->g); - cmph_hash_state_destroy(data->hashes[0]); - cmph_hash_state_destroy(data->hashes[1]); + hash_state_destroy(data->hashes[0]); + hash_state_destroy(data->hashes[1]); free(data->hashes); free(data); free(mphf); diff --git a/src/bmz.h b/src/bmz.h index 6095b91..7a81a02 100644 --- a/src/bmz.h +++ b/src/bmz.h @@ -1,19 +1,18 @@ -#ifndef __BMZ_H__ -#define __BMZ_H__ +#ifndef __CMPH_BMZ_H__ +#define __CMPH_BMZ_H__ -#include "graph.h" #include "cmph.h" -typedef struct cmph__bmz_mphf_data_t cmph_bmz_mphf_data_t; -typedef struct cmph__bmz_mph_data_t cmph_bmz_mph_data_t; +typedef struct __bmz_data_t bmz_data_t; +typedef struct __bmz_config_data_t bmz_config_data_t; -cmph_mph_t *cmph_bmz_mph_new(cmph_key_source_t *key_source); -void cmph_bmz_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs); -void cmph_bmz_mph_destroy(cmph_mph_t *mph); -cmph_mphf_t *cmph_bmz_mph_create(cmph_mph_t *mph, float bmz_c); +bmz_config_data_t *bmz_config_new(cmph_key_source_t *key_source); +void bmz_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs); +void bmz_config_destroy(cmph_config_t *mph); +cmph_t *bmz_new(cmph_config_t *mph, float c); -void cmph_bmz_mphf_load(FILE *f, cmph_mphf_t *mphf); -int cmph_bmz_mphf_dump(cmph_mphf_t *mphf, FILE *f); -void cmph_bmz_mphf_destroy(cmph_mphf_t *mphf); -cmph_uint32 cmph_bmz_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 keylen); +void bmz_load(FILE *f, cmph_t *mphf); +int bmz_dump(cmph_t *mphf, FILE *f); +void bmz_destroy(cmph_t *mphf); +cmph_uint32 bmz_search(cmph_t *mphf, const char *key, cmph_uint32 keylen); #endif diff --git a/src/bmz_structs.h b/src/bmz_structs.h index a906d6d..63378e5 100644 --- a/src/bmz_structs.h +++ b/src/bmz_structs.h @@ -1,24 +1,24 @@ -#ifndef __BMZ_STRUCTS_H__ -#define __BMZ_STRUCTS_H__ +#ifndef __CMPH_BMZ_STRUCTS_H__ +#define __CMPH_BMZ_STRUCTS_H__ #include "hash_state.h" -struct cmph__bmz_mphf_data_t +struct __bmz_data_t { cmph_uint32 m; //edges (words) count cmph_uint32 n; //vertex count cmph_uint32 *g; - cmph_hash_state_t **hashes; + hash_state_t **hashes; }; -struct cmph__bmz_mph_data_t +struct __bmz_config_data_t { CMPH_HASH hashfuncs[2]; cmph_uint32 m; //edges (words) count cmph_uint32 n; //vertex count - cmph_graph_t *graph; + graph_t *graph; cmph_uint32 *g; - cmph_hash_state_t **hashes; + hash_state_t **hashes; }; #endif diff --git a/src/cmph.c b/src/cmph.c index 74e5bad..bb52106 100644 --- a/src/cmph.c +++ b/src/cmph.c @@ -10,85 +10,84 @@ //#define DEBUG #include "debug.h" -const char *cmph_names[] = { "czech", "bmz", NULL }; /* included -- Fabiano */ +const char *cmph_names[] = { "bmz", "czech", NULL }; /* included -- Fabiano */ -cmph_mph_t *cmph_mph_new(CMPH_ALGO algo, cmph_key_source_t *key_source) +cmph_config_t *cmph_config_new(cmph_key_source_t *key_source) { - cmph_mph_t *mph = NULL; - DEBUGP("Creating mph with algorithm %s\n", cmph_names[algo]); - switch (algo) - { - case CMPH_CZECH: - mph = cmph_czech_mph_new(key_source); - break; - case CMPH_BMZ: /* included -- Fabiano */ - DEBUGP("new bmz algorithm \n"); - mph = cmph_bmz_mph_new(key_source); - break; - default: - assert(0); - } + cmph_config_t *mph = NULL; + mph = __config_new(key_source); assert(mph); + mph->algo = CMPH_CZECH; // default value return mph; } -void cmph_mph_destroy(cmph_mph_t *mph) +void cmph_config_set_algo(cmph_config_t *mph, CMPH_ALGO algo) +{ + mph->algo = algo; +} + +void cmph_config_destroy(cmph_config_t *mph) { DEBUGP("Destroying mph with algo %s\n", cmph_names[mph->algo]); switch (mph->algo) { case CMPH_CZECH: - cmph_czech_mph_destroy(mph); + czech_config_destroy(mph); break; case CMPH_BMZ: /* included -- Fabiano */ - cmph_bmz_mph_destroy(mph); + bmz_config_destroy(mph); break; default: assert(0); } + __config_destroy(mph); } -void cmph_mph_set_verbosity(cmph_mph_t *mph, cmph_uint32 verbosity) +void cmph_config_set_verbosity(cmph_config_t *mph, cmph_uint32 verbosity) { mph->verbosity = verbosity; } -void cmph_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs) +void cmph_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs) { switch (mph->algo) { case CMPH_CZECH: - cmph_czech_mph_set_hashfuncs(mph, hashfuncs); + czech_config_set_hashfuncs(mph, hashfuncs); break; case CMPH_BMZ: /* included -- Fabiano */ - cmph_bmz_mph_set_hashfuncs(mph, hashfuncs); + bmz_config_set_hashfuncs(mph, hashfuncs); break; default: break; } return; } -void cmph_mph_set_graphsize(cmph_mph_t *mph, float c) +void cmph_config_set_graphsize(cmph_config_t *mph, float c) { mph->c = c; return; } -cmph_mphf_t *cmph_mph_create(cmph_mph_t *mph) +cmph_t *cmph_new(cmph_config_t *mph) { - cmph_mphf_t *mphf = NULL; + cmph_t *mphf = NULL; float c = mph->c; + + DEBUGP("Creating mph with algorithm %s\n", cmph_names[mph->algo]); switch (mph->algo) { case CMPH_CZECH: DEBUGP("Creating czech hash\n"); + mph->data = czech_config_new(mph->key_source); if (c == 0) c = 2.09; - mphf = cmph_czech_mph_create(mph, c); + mphf = czech_new(mph, c); break; case CMPH_BMZ: /* included -- Fabiano */ DEBUGP("Creating bmz hash\n"); + mph->data = bmz_config_new(mph->key_source); if (c == 0) c = 1.15; - mphf = cmph_bmz_mph_create(mph, c); + mphf = bmz_new(mph, c); break; default: assert(0); @@ -96,15 +95,15 @@ cmph_mphf_t *cmph_mph_create(cmph_mph_t *mph) return mphf; } -int cmph_mphf_dump(cmph_mphf_t *mphf, FILE *f) +int cmph_dump(cmph_t *mphf, FILE *f) { switch (mphf->algo) { case CMPH_CZECH: - return cmph_czech_mphf_dump(mphf, f); + return czech_dump(mphf, f); break; case CMPH_BMZ: /* included -- Fabiano */ - return cmph_bmz_mphf_dump(mphf, f); + return bmz_dump(mphf, f); break; default: assert(0); @@ -112,22 +111,22 @@ int cmph_mphf_dump(cmph_mphf_t *mphf, FILE *f) assert(0); return 0; } -cmph_mphf_t *cmph_mphf_load(FILE *f) +cmph_t *cmph_load(FILE *f) { - cmph_mphf_t *mphf = NULL; + cmph_t *mphf = NULL; DEBUGP("Loading mphf generic parts\n"); - mphf = cmph__mphf_load(f); + mphf = __cmph_load(f); if (mphf == NULL) return NULL; DEBUGP("Loading mphf algorithm dependent parts\n"); switch (mphf->algo) { case CMPH_CZECH: - cmph_czech_mphf_load(f, mphf); + czech_load(f, mphf); break; case CMPH_BMZ: /* included -- Fabiano */ DEBUGP("Loading bmz algorithm dependent parts\n"); - cmph_bmz_mphf_load(f, mphf); + bmz_load(f, mphf); break; default: assert(0); @@ -137,16 +136,16 @@ cmph_mphf_t *cmph_mphf_load(FILE *f) } -cmph_uint32 cmph_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 keylen) +cmph_uint32 cmph_search(cmph_t *mphf, const char *key, cmph_uint32 keylen) { DEBUGP("mphf algorithm: %u \n", mphf->algo); switch(mphf->algo) { case CMPH_CZECH: - return cmph_czech_mphf_search(mphf, key, keylen); + return czech_search(mphf, key, keylen); case CMPH_BMZ: /* included -- Fabiano */ DEBUGP("bmz algorithm search\n"); - return cmph_bmz_mphf_search(mphf, key, keylen); + return bmz_search(mphf, key, keylen); default: assert(0); } @@ -154,20 +153,20 @@ cmph_uint32 cmph_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 key return 0; } -cmph_uint32 cmph_mphf_size(cmph_mphf_t *mphf) +cmph_uint32 cmph_size(cmph_t *mphf) { return mphf->size; } -void cmph_mphf_destroy(cmph_mphf_t *mphf) +void cmph_destroy(cmph_t *mphf) { switch(mphf->algo) { case CMPH_CZECH: - cmph_czech_mphf_destroy(mphf); + czech_destroy(mphf); return; case CMPH_BMZ: /* included -- Fabiano */ - cmph_bmz_mphf_destroy(mphf); + bmz_destroy(mphf); return; default: assert(0); diff --git a/src/cmph.h b/src/cmph.h index 5ad98fb..f74de32 100644 --- a/src/cmph.h +++ b/src/cmph.h @@ -11,8 +11,8 @@ extern "C" #include "cmph_types.h" -typedef struct cmph__mph_t cmph_mph_t; -typedef struct cmph__mphf_t cmph_mphf_t; +typedef struct __config_t cmph_config_t; +typedef struct __cmph_t cmph_t; typedef struct { @@ -24,19 +24,20 @@ typedef struct } cmph_key_source_t; /** Hash generation API **/ -cmph_mph_t *cmph_mph_new(CMPH_ALGO algo, cmph_key_source_t *key_source); -void cmph_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs); -void cmph_mph_set_verbosity(cmph_mph_t *mph, cmph_uint32 verbosity); -void cmph_mph_set_graphsize(cmph_mph_t *mph, float c); -void cmph_mph_destroy(cmph_mph_t *mph); -cmph_mphf_t *cmph_mph_create(cmph_mph_t *mph); +cmph_config_t *cmph_config_new(cmph_key_source_t *key_source); +void cmph_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs); +void cmph_config_set_verbosity(cmph_config_t *mph, cmph_uint32 verbosity); +void cmph_config_set_graphsize(cmph_config_t *mph, float c); +void cmph_config_set_algo(cmph_config_t *mph, CMPH_ALGO algo); +void cmph_config_destroy(cmph_config_t *mph); +cmph_t *cmph_new(cmph_config_t *mph); /** Hash querying API **/ -cmph_mphf_t *cmph_mphf_load(FILE *f); -int cmph_mphf_dump(cmph_mphf_t *mphf, FILE *f); -cmph_uint32 cmph_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 keylen); -cmph_uint32 cmph_mphf_size(cmph_mphf_t *mphf); -void cmph_mphf_destroy(cmph_mphf_t *mphf); +cmph_t *cmph_load(FILE *f); +int cmph_dump(cmph_t *mphf, FILE *f); +cmph_uint32 cmph_search(cmph_t *mphf, const char *key, cmph_uint32 keylen); +cmph_uint32 cmph_size(cmph_t *mphf); +void cmph_destroy(cmph_t *mphf); #ifdef __cplusplus } diff --git a/src/cmph_structs.c b/src/cmph_structs.c index ee1e89f..060fbd8 100644 --- a/src/cmph_structs.c +++ b/src/cmph_structs.c @@ -5,32 +5,31 @@ //#define DEBUG #include "debug.h" -cmph_mph_t *cmph__mph_new(CMPH_ALGO algo, cmph_key_source_t *key_source) +cmph_config_t *__config_new(cmph_key_source_t *key_source) { - cmph_mph_t *mph = (cmph_mph_t *)malloc(sizeof(cmph_mph_t)); + cmph_config_t *mph = (cmph_config_t *)malloc(sizeof(cmph_config_t)); DEBUGP("Creating mph with algorithm %s\n", cmph_names[algo]); if (mph == NULL) return NULL; - mph->algo = algo; mph->key_source = key_source; mph->verbosity = 0; float c = 0; return mph; } -void cmph__mph_destroy(cmph_mph_t *mph) +void __config_destroy(cmph_config_t *mph) { free(mph); } -void cmph__mphf_dump(cmph_mphf_t *mphf, FILE *fd) +void __cmph_dump(cmph_t *mphf, FILE *fd) { cmph_uint32 nsize = htonl(mphf->size); fwrite(cmph_names[mphf->algo], (cmph_uint32)(strlen(cmph_names[mphf->algo]) + 1), 1, fd); fwrite(&nsize, sizeof(mphf->size), 1, fd); } -cmph_mphf_t *cmph__mphf_load(FILE *f) +cmph_t *__cmph_load(FILE *f) { - cmph_mphf_t *mphf = NULL; + cmph_t *mphf = NULL; cmph_uint32 i; char algo_name[BUFSIZ]; char *ptr = algo_name; @@ -56,7 +55,7 @@ cmph_mphf_t *cmph__mphf_load(FILE *f) DEBUGP("Algorithm %s not found\n", algo_name); return NULL; } - mphf = (cmph_mphf_t *)malloc(sizeof(cmph_mphf_t)); + mphf = (cmph_t *)malloc(sizeof(cmph_t)); mphf->algo = algo; fread(&(mphf->size), sizeof(mphf->size), 1, f); mphf->size = ntohl(mphf->size); diff --git a/src/cmph_structs.h b/src/cmph_structs.h index 65c8784..436e363 100644 --- a/src/cmph_structs.h +++ b/src/cmph_structs.h @@ -5,7 +5,7 @@ /** Hash generation algorithm data */ -struct cmph__mph_t +struct __config_t { CMPH_ALGO algo; cmph_key_source_t *key_source; @@ -16,7 +16,7 @@ struct cmph__mph_t /** Hash querying algorithm data */ -struct cmph__mphf_t +struct __cmph_t { CMPH_ALGO algo; cmph_uint32 size; @@ -24,10 +24,10 @@ struct cmph__mphf_t void *data; //algorithm dependent data }; -cmph_mph_t *cmph__mph_new(CMPH_ALGO algo, cmph_key_source_t *key_source); -void cmph__mph_destroy(); -void cmph__mphf_dump(cmph_mphf_t *mphf, FILE *); -cmph_mphf_t *cmph__mphf_load(FILE *f); +cmph_config_t *__config_new(cmph_key_source_t *key_source); +void __config_destroy(); +void __cmph_dump(cmph_t *mphf, FILE *); +cmph_t *__cmph_load(FILE *f); #endif diff --git a/src/czech.c b/src/czech.c index c4e1a96..e7498e0 100644 --- a/src/czech.c +++ b/src/czech.c @@ -1,7 +1,9 @@ +#include "graph.h" #include "czech.h" #include "cmph_structs.h" #include "czech_structs.h" #include "hash.h" +#include "bitbool.h" #include #include @@ -13,46 +15,36 @@ //#define DEBUG #include "debug.h" -static const char bitmask[8] = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 }; -#define GETBIT(array, i) (array[(i) / 8] & bitmask[(i) % 8]) -#define SETBIT(array, i) (array[(i) / 8] |= bitmask[(i) % 8]) -#define UNSETBIT(array, i) (array[(i) / 8] &= (~(bitmask[(i) % 8]))) +/* static const char bitmask[8] = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 }; */ +/* #define GETBIT(array, i) (array[(i) / 8] & bitmask[(i) % 8]) */ +/* #define SETBIT(array, i) (array[(i) / 8] |= bitmask[(i) % 8]) */ +/* #define UNSETBIT(array, i) (array[(i) / 8] &= (~(bitmask[(i) % 8]))) */ -static int czech_gen_edges(cmph_mph_t *mph); -static void czech_traverse(cmph_czech_mph_data_t *czech, cmph_uint8 *visited, cmph_uint32 v); +static int czech_gen_edges(cmph_config_t *mph); +static void czech_traverse(czech_config_data_t *czech, cmph_uint8 *visited, cmph_uint32 v); -cmph_mph_t *cmph_czech_mph_new(cmph_key_source_t *key_source) +czech_config_data_t *czech_config_new(cmph_key_source_t *key_source) { - cmph_mph_t *mph = NULL; - cmph_czech_mph_data_t *czech = NULL; - mph = cmph__mph_new(CMPH_CZECH, key_source); - if (mph == NULL) return NULL; - czech = (cmph_czech_mph_data_t *)malloc(sizeof(cmph_czech_mph_data_t)); - if (czech == NULL) - { - cmph__mph_destroy(mph); - return NULL; - } + czech_config_data_t *czech = NULL; + czech = (czech_config_data_t *)malloc(sizeof(czech_config_data_t)); czech->hashfuncs[0] = CMPH_HASH_JENKINS; czech->hashfuncs[1] = CMPH_HASH_JENKINS; czech->g = NULL; czech->graph = NULL; czech->hashes = NULL; - mph->data = czech; - assert(mph->data); - return mph; + assert(czech); + return czech; } -void cmph_czech_mph_destroy(cmph_mph_t *mph) +void czech_config_destroy(cmph_config_t *mph) { - cmph_czech_mph_data_t *data = (cmph_czech_mph_data_t *)mph->data; + czech_config_data_t *data = (czech_config_data_t *)mph->data; DEBUGP("Destroying algorithm dependent data\n"); free(data); - cmph__mph_destroy(mph); } -void cmph_czech_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs) +void czech_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs) { - cmph_czech_mph_data_t *czech = (cmph_czech_mph_data_t *)mph->data; + czech_config_data_t *czech = (czech_config_data_t *)mph->data; CMPH_HASH *hashptr = hashfuncs; cmph_uint32 i = 0; while(*hashptr != CMPH_HASH_COUNT) @@ -63,22 +55,22 @@ void cmph_czech_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs) } } -cmph_mphf_t *cmph_czech_mph_create(cmph_mph_t *mph, float c) +cmph_t *czech_new(cmph_config_t *mph, float c) { - cmph_mphf_t *mphf = NULL; - cmph_czech_mphf_data_t *czechf = NULL; + cmph_t *mphf = NULL; + czech_data_t *czechf = NULL; cmph_uint32 i; cmph_uint32 iterations = 20; cmph_uint8 *visited = NULL; - cmph_czech_mph_data_t *czech = (cmph_czech_mph_data_t *)mph->data; + czech_config_data_t *czech = (czech_config_data_t *)mph->data; czech->m = mph->key_source->nkeys; czech->n = ceil(c * mph->key_source->nkeys); DEBUGP("m (edges): %u n (vertices): %u c: %f\n", czech->m, czech->n, c); - czech->graph = cmph_graph_new(czech->n, czech->m); + czech->graph = graph_new(czech->n, czech->m); DEBUGP("Created graph\n"); - czech->hashes = (cmph_hash_state_t **)malloc(sizeof(cmph_hash_state_t *)*3); + czech->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*3); for(i = 0; i < 3; ++i) czech->hashes[i] = NULL; //Mapping step if (mph->verbosity) @@ -88,15 +80,15 @@ cmph_mphf_t *cmph_czech_mph_create(cmph_mph_t *mph, float c) while(1) { int ok; - czech->hashes[0] = cmph_hash_state_new(czech->hashfuncs[0], czech->n); - czech->hashes[1] = cmph_hash_state_new(czech->hashfuncs[1], czech->n); + czech->hashes[0] = hash_state_new(czech->hashfuncs[0], czech->n); + czech->hashes[1] = hash_state_new(czech->hashfuncs[1], czech->n); ok = czech_gen_edges(mph); if (!ok) { --iterations; - cmph_hash_state_destroy(czech->hashes[0]); + hash_state_destroy(czech->hashes[0]); czech->hashes[0] = NULL; - cmph_hash_state_destroy(czech->hashes[1]); + hash_state_destroy(czech->hashes[1]); czech->hashes[1] = NULL; DEBUGP("%u iterations remaining\n", iterations); if (mph->verbosity) @@ -109,7 +101,7 @@ cmph_mphf_t *cmph_czech_mph_create(cmph_mph_t *mph, float c) } if (iterations == 0) { - cmph_graph_destroy(czech->graph); + graph_destroy(czech->graph); return NULL; } @@ -132,13 +124,13 @@ cmph_mphf_t *cmph_czech_mph_create(cmph_mph_t *mph, float c) czech_traverse(czech, visited, i); } } - cmph_graph_destroy(czech->graph); + graph_destroy(czech->graph); free(visited); czech->graph = NULL; - mphf = (cmph_mphf_t *)malloc(sizeof(cmph_mphf_t)); + mphf = (cmph_t *)malloc(sizeof(cmph_t)); mphf->algo = mph->algo; - czechf = (cmph_czech_mphf_data_t *)malloc(sizeof(cmph_czech_mph_data_t)); + czechf = (czech_data_t *)malloc(sizeof(czech_config_data_t)); czechf->g = czech->g; czech->g = NULL; //transfer memory ownership czechf->hashes = czech->hashes; @@ -155,34 +147,34 @@ cmph_mphf_t *cmph_czech_mph_create(cmph_mph_t *mph, float c) return mphf; } -static void czech_traverse(cmph_czech_mph_data_t *czech, cmph_uint8 *visited, cmph_uint32 v) +static void czech_traverse(czech_config_data_t *czech, cmph_uint8 *visited, cmph_uint32 v) { - cmph_graph_iterator_t it = cmph_graph_neighbors_it(czech->graph, v); + graph_iterator_t it = graph_neighbors_it(czech->graph, v); cmph_uint32 neighbor = 0; SETBIT(visited,v); DEBUGP("Visiting vertex %u\n", v); - while((neighbor = cmph_graph_next_neighbor(czech->graph, &it)) != CMPH_GRAPH_NO_NEIGHBOR) + while((neighbor = graph_next_neighbor(czech->graph, &it)) != GRAPH_NO_NEIGHBOR) { DEBUGP("Visiting neighbor %u\n", neighbor); if(GETBIT(visited,neighbor)) continue; DEBUGP("Visiting neighbor %u\n", neighbor); - DEBUGP("Visiting edge %u->%u with id %u\n", v, neighbor, cmph_graph_edge_id(czech->graph, v, neighbor)); - czech->g[neighbor] = cmph_graph_edge_id(czech->graph, v, neighbor) - czech->g[v]; - DEBUGP("g is %u (%u - %u mod %u)\n", czech->g[neighbor], cmph_graph_edge_id(czech->graph, v, neighbor), czech->g[v], czech->m); + DEBUGP("Visiting edge %u->%u with id %u\n", v, neighbor, graph_edge_id(czech->graph, v, neighbor)); + czech->g[neighbor] = graph_edge_id(czech->graph, v, neighbor) - czech->g[v]; + DEBUGP("g is %u (%u - %u mod %u)\n", czech->g[neighbor], graph_edge_id(czech->graph, v, neighbor), czech->g[v], czech->m); czech_traverse(czech, visited, neighbor); } } -static int czech_gen_edges(cmph_mph_t *mph) +static int czech_gen_edges(cmph_config_t *mph) { cmph_uint32 e; - cmph_czech_mph_data_t *czech = (cmph_czech_mph_data_t *)mph->data; + czech_config_data_t *czech = (czech_config_data_t *)mph->data; int cycles = 0; DEBUGP("Generating edges for %u vertices\n", czech->n); - cmph_graph_clear_edges(czech->graph); + graph_clear_edges(czech->graph); mph->key_source->rewind(mph->key_source->data); for (e = 0; e < mph->key_source->nkeys; ++e) { @@ -190,8 +182,8 @@ static int czech_gen_edges(cmph_mph_t *mph) cmph_uint32 keylen; char *key; mph->key_source->read(mph->key_source->data, &key, &keylen); - h1 = cmph_hash(czech->hashes[0], key, keylen) % czech->n; - h2 = cmph_hash(czech->hashes[1], key, keylen) % czech->n; + h1 = hash(czech->hashes[0], key, keylen) % czech->n; + h2 = hash(czech->hashes[1], key, keylen) % czech->n; if (h1 == h2) if (++h2 >= czech->n) h2 = 0; if (h1 == h2) { @@ -201,36 +193,36 @@ static int czech_gen_edges(cmph_mph_t *mph) } DEBUGP("Adding edge: %u -> %u for key %s\n", h1, h2, key); mph->key_source->dispose(mph->key_source->data, key, keylen); - cmph_graph_add_edge(czech->graph, h1, h2); + graph_add_edge(czech->graph, h1, h2); } - cycles = cmph_graph_is_cyclic(czech->graph); + cycles = graph_is_cyclic(czech->graph); if (mph->verbosity && cycles) fprintf(stderr, "Cyclic graph generated\n"); DEBUGP("Looking for cycles: %u\n", cycles); return ! cycles; } -int cmph_czech_mphf_dump(cmph_mphf_t *mphf, FILE *fd) +int czech_dump(cmph_t *mphf, FILE *fd) { char *buf = NULL; cmph_uint32 buflen; cmph_uint32 nbuflen; cmph_uint32 i; cmph_uint32 two = htonl(2); //number of hash functions - cmph_czech_mphf_data_t *data = (cmph_czech_mphf_data_t *)mphf->data; + czech_data_t *data = (czech_data_t *)mphf->data; cmph_uint32 nn, nm; - cmph__mphf_dump(mphf, fd); + __cmph_dump(mphf, fd); fwrite(&two, sizeof(cmph_uint32), 1, fd); - cmph_hash_state_dump(data->hashes[0], &buf, &buflen); + hash_state_dump(data->hashes[0], &buf, &buflen); DEBUGP("Dumping hash state with %u bytes to disk\n", buflen); nbuflen = htonl(buflen); fwrite(&nbuflen, sizeof(cmph_uint32), 1, fd); fwrite(buf, buflen, 1, fd); free(buf); - cmph_hash_state_dump(data->hashes[1], &buf, &buflen); + hash_state_dump(data->hashes[1], &buf, &buflen); DEBUGP("Dumping hash state with %u bytes to disk\n", buflen); nbuflen = htonl(buflen); fwrite(&nbuflen, sizeof(cmph_uint32), 1, fd); @@ -255,32 +247,32 @@ int cmph_czech_mphf_dump(cmph_mphf_t *mphf, FILE *fd) return 1; } -void cmph_czech_mphf_load(FILE *f, cmph_mphf_t *mphf) +void czech_load(FILE *f, cmph_t *mphf) { cmph_uint32 nhashes; char fbuf[BUFSIZ]; char *buf = NULL; cmph_uint32 buflen; cmph_uint32 i; - cmph_hash_state_t *state; - cmph_czech_mphf_data_t *czech = (cmph_czech_mphf_data_t *)malloc(sizeof(cmph_czech_mphf_data_t)); + hash_state_t *state; + czech_data_t *czech = (czech_data_t *)malloc(sizeof(czech_data_t)); DEBUGP("Loading czech mphf\n"); mphf->data = czech; fread(&nhashes, sizeof(cmph_uint32), 1, f); nhashes = ntohl(nhashes); - czech->hashes = (cmph_hash_state_t **)malloc(sizeof(cmph_hash_state_t *)*(nhashes + 1)); + czech->hashes = (hash_state_t **)malloc(sizeof(hash_state_t *)*(nhashes + 1)); czech->hashes[nhashes] = NULL; DEBUGP("Reading %u hashes\n", nhashes); for (i = 0; i < nhashes; ++i) { - cmph_hash_state_t *state = NULL; + hash_state_t *state = NULL; fread(&buflen, sizeof(cmph_uint32), 1, f); buflen = ntohl(buflen); DEBUGP("Hash state has %u bytes\n", buflen); buf = (char *)malloc(buflen); fread(buf, buflen, 1, f); - state = cmph_hash_state_load(buf, buflen); + state = hash_state_load(buf, buflen); czech->hashes[i] = state; free(buf); } @@ -303,22 +295,22 @@ void cmph_czech_mphf_load(FILE *f, cmph_mphf_t *mphf) } -cmph_uint32 cmph_czech_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 keylen) +cmph_uint32 czech_search(cmph_t *mphf, const char *key, cmph_uint32 keylen) { - cmph_czech_mphf_data_t *czech = mphf->data; - cmph_uint32 h1 = cmph_hash(czech->hashes[0], key, keylen) % czech->n; - cmph_uint32 h2 = cmph_hash(czech->hashes[1], key, keylen) % czech->n; + czech_data_t *czech = mphf->data; + cmph_uint32 h1 = hash(czech->hashes[0], key, keylen) % czech->n; + cmph_uint32 h2 = hash(czech->hashes[1], key, keylen) % czech->n; DEBUGP("key: %s h1: %u h2: %u\n", key, h1, h2); if (h1 == h2 && ++h2 > czech->n) h2 = 0; DEBUGP("key: %s g[h1]: %u g[h2]: %u edges: %u\n", key, czech->g[h1], czech->g[h2], czech->m); return (czech->g[h1] + czech->g[h2]) % czech->m; } -void cmph_czech_mphf_destroy(cmph_mphf_t *mphf) +void czech_destroy(cmph_t *mphf) { - cmph_czech_mphf_data_t *data = (cmph_czech_mphf_data_t *)mphf->data; + czech_data_t *data = (czech_data_t *)mphf->data; free(data->g); - cmph_hash_state_destroy(data->hashes[0]); - cmph_hash_state_destroy(data->hashes[1]); + hash_state_destroy(data->hashes[0]); + hash_state_destroy(data->hashes[1]); free(data->hashes); free(data); free(mphf); diff --git a/src/czech.h b/src/czech.h index d167219..9070e89 100644 --- a/src/czech.h +++ b/src/czech.h @@ -1,19 +1,18 @@ -#ifndef __CZECH_H__ -#define __CZECH_H__ +#ifndef __CMPH_CZECH_H__ +#define __CMPH_CZECH_H__ -#include "graph.h" #include "cmph.h" -typedef struct cmph__czech_mphf_data_t cmph_czech_mphf_data_t; -typedef struct cmph__czech_mph_data_t cmph_czech_mph_data_t; +typedef struct __czech_data_t czech_data_t; +typedef struct __czech_config_data_t czech_config_data_t; -cmph_mph_t *cmph_czech_mph_new(cmph_key_source_t *key_source); -void cmph_czech_mph_set_hashfuncs(cmph_mph_t *mph, CMPH_HASH *hashfuncs); -void cmph_czech_mph_destroy(cmph_mph_t *mph); -cmph_mphf_t *cmph_czech_mph_create(cmph_mph_t *mph, float c); +czech_config_data_t *czech_config_new(cmph_key_source_t *key_source); +void czech_config_set_hashfuncs(cmph_config_t *mph, CMPH_HASH *hashfuncs); +void czech_config_destroy(cmph_config_t *mph); +cmph_t *czech_new(cmph_config_t *mph, float c); -void cmph_czech_mphf_load(FILE *f, cmph_mphf_t *mphf); -int cmph_czech_mphf_dump(cmph_mphf_t *mphf, FILE *f); -void cmph_czech_mphf_destroy(cmph_mphf_t *mphf); -cmph_uint32 cmph_czech_mphf_search(cmph_mphf_t *mphf, const char *key, cmph_uint32 keylen); +void czech_load(FILE *f, cmph_t *mphf); +int czech_dump(cmph_t *mphf, FILE *f); +void czech_destroy(cmph_t *mphf); +cmph_uint32 czech_search(cmph_t *mphf, const char *key, cmph_uint32 keylen); #endif diff --git a/src/czech_structs.h b/src/czech_structs.h index 1678433..a03bc6e 100644 --- a/src/czech_structs.h +++ b/src/czech_structs.h @@ -1,24 +1,24 @@ -#ifndef __CZECH_STRUCTS_H__ -#define __CZECH_STRUCTS_H__ +#ifndef __CMPH_CZECH_STRUCTS_H__ +#define __CMPH_CZECH_STRUCTS_H__ #include "hash_state.h" -struct cmph__czech_mphf_data_t +struct __czech_data_t { cmph_uint32 m; //edges (words) count cmph_uint32 n; //vertex count cmph_uint32 *g; - cmph_hash_state_t **hashes; + hash_state_t **hashes; }; -struct cmph__czech_mph_data_t +struct __czech_config_data_t { CMPH_HASH hashfuncs[2]; cmph_uint32 m; //edges (words) count cmph_uint32 n; //vertex count - cmph_graph_t *graph; + graph_t *graph; cmph_uint32 *g; - cmph_hash_state_t **hashes; + hash_state_t **hashes; }; #endif diff --git a/src/djb2_hash.c b/src/djb2_hash.c index 6e5b972..5bbd9bd 100644 --- a/src/djb2_hash.c +++ b/src/djb2_hash.c @@ -1,19 +1,19 @@ #include "djb2_hash.h" #include -cmph_djb2_state_t *cmph_djb2_state_new() +djb2_state_t *djb2_state_new() { - cmph_djb2_state_t *state = (cmph_djb2_state_t *)malloc(sizeof(cmph_djb2_state_t)); + djb2_state_t *state = (djb2_state_t *)malloc(sizeof(djb2_state_t)); state->hashfunc = CMPH_HASH_DJB2; return state; } -void cmph_djb2_state_destroy(cmph_djb2_state_t *state) +void djb2_state_destroy(djb2_state_t *state) { free(state); } -cmph_uint32 cmph_djb2_hash(cmph_djb2_state_t *state, const char *k, cmph_uint32 keylen) +cmph_uint32 djb2_hash(djb2_state_t *state, const char *k, cmph_uint32 keylen) { register cmph_uint32 hash = 5381; const unsigned char *ptr = k; @@ -27,16 +27,16 @@ cmph_uint32 cmph_djb2_hash(cmph_djb2_state_t *state, const char *k, cmph_uint32 } -void cmph_djb2_state_dump(cmph_djb2_state_t *state, char **buf, cmph_uint32 *buflen) +void djb2_state_dump(djb2_state_t *state, char **buf, cmph_uint32 *buflen) { *buf = NULL; *buflen = 0; return; } -cmph_djb2_state_t *cmph_djb2_state_load(const char *buf, cmph_uint32 buflen) +djb2_state_t *djb2_state_load(const char *buf, cmph_uint32 buflen) { - cmph_djb2_state_t *state = (cmph_djb2_state_t *)malloc(sizeof(cmph_djb2_state_t)); + djb2_state_t *state = (djb2_state_t *)malloc(sizeof(djb2_state_t)); state->hashfunc = CMPH_HASH_DJB2; return state; } diff --git a/src/djb2_hash.h b/src/djb2_hash.h index 549cc90..3fef71d 100644 --- a/src/djb2_hash.h +++ b/src/djb2_hash.h @@ -3,15 +3,15 @@ #include "hash.h" -typedef struct cmph__djb2_state_t +typedef struct __djb2_state_t { CMPH_HASH hashfunc; -} cmph_djb2_state_t; +} djb2_state_t; -cmph_djb2_state_t *cmph_djb2_state_new(); -cmph_uint32 cmph_djb2_hash(cmph_djb2_state_t *state, const char *k, cmph_uint32 keylen); -void cmph_djb2_state_dump(cmph_djb2_state_t *state, char **buf, cmph_uint32 *buflen); -cmph_djb2_state_t *cmph_djb2_state_load(const char *buf, cmph_uint32 buflen); -void cmph_djb2_state_destroy(cmph_djb2_state_t *state); +djb2_state_t *djb2_state_new(); +cmph_uint32 djb2_hash(djb2_state_t *state, const char *k, cmph_uint32 keylen); +void djb2_state_dump(djb2_state_t *state, char **buf, cmph_uint32 *buflen); +djb2_state_t *djb2_state_load(const char *buf, cmph_uint32 buflen); +void djb2_state_destroy(djb2_state_t *state); #endif diff --git a/src/fnv_hash.c b/src/fnv_hash.c index 9be1558..5bf8db2 100644 --- a/src/fnv_hash.c +++ b/src/fnv_hash.c @@ -1,19 +1,19 @@ #include "fnv_hash.h" #include -cmph_fnv_state_t *cmph_fnv_state_new() +fnv_state_t *fnv_state_new() { - cmph_fnv_state_t *state = (cmph_fnv_state_t *)malloc(sizeof(cmph_fnv_state_t)); + fnv_state_t *state = (fnv_state_t *)malloc(sizeof(fnv_state_t)); state->hashfunc = CMPH_HASH_FNV; return state; } -void cmph_fnv_state_destroy(cmph_fnv_state_t *state) +void fnv_state_destroy(fnv_state_t *state) { free(state); } -cmph_uint32 cmph_fnv_hash(cmph_fnv_state_t *state, const char *k, cmph_uint32 keylen) +cmph_uint32 fnv_hash(fnv_state_t *state, const char *k, cmph_uint32 keylen) { const unsigned char *bp = (const unsigned char *)k; const unsigned char *be = bp + keylen; @@ -31,16 +31,16 @@ cmph_uint32 cmph_fnv_hash(cmph_fnv_state_t *state, const char *k, cmph_uint32 ke } -void cmph_fnv_state_dump(cmph_fnv_state_t *state, char **buf, cmph_uint32 *buflen) +void fnv_state_dump(fnv_state_t *state, char **buf, cmph_uint32 *buflen) { *buf = NULL; *buflen = 0; return; } -cmph_fnv_state_t *cmph_fnv_state_load(const char *buf, cmph_uint32 buflen) +fnv_state_t *fnv_state_load(const char *buf, cmph_uint32 buflen) { - cmph_fnv_state_t *state = (cmph_fnv_state_t *)malloc(sizeof(cmph_fnv_state_t)); + fnv_state_t *state = (fnv_state_t *)malloc(sizeof(fnv_state_t)); state->hashfunc = CMPH_HASH_FNV; return state; } diff --git a/src/fnv_hash.h b/src/fnv_hash.h index e9e54fa..e73e0f6 100644 --- a/src/fnv_hash.h +++ b/src/fnv_hash.h @@ -3,15 +3,15 @@ #include "hash.h" -typedef struct cmph__fnv_state_t +typedef struct __fnv_state_t { CMPH_HASH hashfunc; -} cmph_fnv_state_t; +} fnv_state_t; -cmph_fnv_state_t *cmph_fnv_state_new(); -cmph_uint32 cmph_fnv_hash(cmph_fnv_state_t *state, const char *k, cmph_uint32 keylen); -void cmph_fnv_state_dump(cmph_fnv_state_t *state, char **buf, cmph_uint32 *buflen); -cmph_fnv_state_t *cmph_fnv_state_load(const char *buf, cmph_uint32 buflen); -void cmph_fnv_state_destroy(cmph_fnv_state_t *state); +fnv_state_t *fnv_state_new(); +cmph_uint32 fnv_hash(fnv_state_t *state, const char *k, cmph_uint32 keylen); +void fnv_state_dump(fnv_state_t *state, char **buf, cmph_uint32 *buflen); +fnv_state_t *fnv_state_load(const char *buf, cmph_uint32 buflen); +void fnv_state_destroy(fnv_state_t *state); #endif diff --git a/src/graph.c b/src/graph.c index 60e2d13..5f1346e 100644 --- a/src/graph.c +++ b/src/graph.c @@ -6,18 +6,19 @@ #include #include #include "vstack.h" +#include "bitbool.h" //#define DEBUG #include "debug.h" -static const cmph_uint8 bitmask[8] = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 }; -#define GETBIT(array, i) (array[(i) / 8] & bitmask[(i) % 8]) -#define SETBIT(array, i) (array[(i) / 8] |= bitmask[(i) % 8]) -#define UNSETBIT(array, i) (array[(i) / 8] &= (~(bitmask[(i) % 8]))) +/* static const cmph_uint8 bitmask[8] = { 1, 1 << 1, 1 << 2, 1 << 3, 1 << 4, 1 << 5, 1 << 6, 1 << 7 }; */ +/* #define GETBIT(array, i) (array[(i) / 8] & bitmask[(i) % 8]) */ +/* #define SETBIT(array, i) (array[(i) / 8] |= bitmask[(i) % 8]) */ +/* #define UNSETBIT(array, i) (array[(i) / 8] &= (~(bitmask[(i) % 8]))) */ #define abs_edge(e, i) (e % g->nedges + i * g->nedges) -struct cmph__graph_t +struct __graph_t { cmph_uint32 nnodes; cmph_uint32 nedges; @@ -32,9 +33,9 @@ struct cmph__graph_t static cmph_uint32 EMPTY = UINT_MAX; -cmph_graph_t *cmph_graph_new(cmph_uint32 nnodes, cmph_uint32 nedges) +graph_t *graph_new(cmph_uint32 nnodes, cmph_uint32 nedges) { - cmph_graph_t *graph = (cmph_graph_t *)malloc(sizeof(cmph_graph_t)); + graph_t *graph = (graph_t *)malloc(sizeof(graph_t)); if (!graph) return NULL; graph->edges = (cmph_uint32 *)malloc(sizeof(cmph_uint32) * 2 * nedges); @@ -45,12 +46,12 @@ cmph_graph_t *cmph_graph_new(cmph_uint32 nnodes, cmph_uint32 nedges) graph->nnodes = nnodes; graph->nedges = nedges; - cmph_graph_clear_edges(graph); + graph_clear_edges(graph); return graph; } -void cmph_graph_destroy(cmph_graph_t *graph) +void graph_destroy(graph_t *graph) { DEBUGP("Destroying graph\n"); free(graph->edges); @@ -61,7 +62,7 @@ void cmph_graph_destroy(cmph_graph_t *graph) return; } -void cmph_graph_print(cmph_graph_t *g) +void graph_print(graph_t *g) { cmph_uint32 i, e; for (i = 0; i < g->nnodes; ++i) @@ -81,7 +82,7 @@ void cmph_graph_print(cmph_graph_t *g) return; } -void cmph_graph_add_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) +void graph_add_edge(graph_t *g, cmph_uint32 v1, cmph_uint32 v2) { cmph_uint32 e = g->cedges; @@ -101,7 +102,7 @@ void cmph_graph_add_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) ++(g->cedges); } -static int check_edge(cmph_graph_t *g, cmph_uint32 e, cmph_uint32 v1, cmph_uint32 v2) +static int check_edge(graph_t *g, cmph_uint32 e, cmph_uint32 v1, cmph_uint32 v2) { DEBUGP("Checking edge %u %u looking for %u %u\n", g->edges[abs_edge(e, 0)], g->edges[abs_edge(e, 1)], v1, v2); if (g->edges[abs_edge(e, 0)] == v1 && g->edges[abs_edge(e, 1)] == v2) return 1; @@ -109,7 +110,7 @@ static int check_edge(cmph_graph_t *g, cmph_uint32 e, cmph_uint32 v1, cmph_uint3 return 0; } -cmph_uint32 cmph_graph_edge_id(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) +cmph_uint32 graph_edge_id(graph_t *g, cmph_uint32 v1, cmph_uint32 v2) { cmph_uint32 e; e = g->first[v1]; @@ -123,7 +124,7 @@ cmph_uint32 cmph_graph_edge_id(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) while (!check_edge(g, e, v1, v2)); return abs_edge(e, 0); } -static void del_edge_point(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) +static void del_edge_point(graph_t *g, cmph_uint32 v1, cmph_uint32 v2) { cmph_uint32 e, prev; @@ -151,14 +152,14 @@ static void del_edge_point(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) } -void cmph_graph_del_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) +void graph_del_edge(graph_t *g, cmph_uint32 v1, cmph_uint32 v2) { g->shrinking = 1; del_edge_point(g, v1, v2); del_edge_point(g, v2, v1); } -void cmph_graph_clear_edges(cmph_graph_t *g) +void graph_clear_edges(graph_t *g) { cmph_uint32 i; for (i = 0; i < g->nnodes; ++i) g->first[i] = EMPTY; @@ -171,7 +172,7 @@ void cmph_graph_clear_edges(cmph_graph_t *g) g->shrinking = 0; } -static int find_degree1_edge(cmph_graph_t *g, cmph_uint32 v, char *deleted, cmph_uint32 *e) +static int find_degree1_edge(graph_t *g, cmph_uint32 v, char *deleted, cmph_uint32 *e) { cmph_uint32 edge = g->first[v]; char found = 0; @@ -195,7 +196,7 @@ static int find_degree1_edge(cmph_graph_t *g, cmph_uint32 v, char *deleted, cmph return found; } -static void cyclic_del_edge(cmph_graph_t *g, cmph_uint32 v, char *deleted) +static void cyclic_del_edge(graph_t *g, cmph_uint32 v, char *deleted) { cmph_uint32 e; @@ -224,7 +225,7 @@ static void cyclic_del_edge(cmph_graph_t *g, cmph_uint32 v, char *deleted) } } -int cmph_graph_is_cyclic(cmph_graph_t *g) +int graph_is_cyclic(graph_t *g) { cmph_uint32 i; cmph_uint32 v; @@ -249,12 +250,12 @@ int cmph_graph_is_cyclic(cmph_graph_t *g) return 0; } -cmph_uint8 cmph_graph_node_is_critical(cmph_graph_t * g, cmph_uint32 v) /* included -- Fabiano */ +cmph_uint8 graph_node_is_critical(graph_t * g, cmph_uint32 v) /* included -- Fabiano */ { return GETBIT(g->critical_nodes,v); } -void cmph_graph_obtain_critical_nodes(cmph_graph_t *g) /* included -- Fabiano*/ +void graph_obtain_critical_nodes(graph_t *g) /* included -- Fabiano*/ { cmph_uint32 i; cmph_uint32 v; @@ -290,7 +291,7 @@ void cmph_graph_obtain_critical_nodes(cmph_graph_t *g) /* included -- Fabiano*/ free(deleted); } -cmph_uint8 cmph_graph_contains_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2) /* included -- Fabiano*/ +cmph_uint8 graph_contains_edge(graph_t *g, cmph_uint32 v1, cmph_uint32 v2) /* included -- Fabiano*/ { cmph_uint32 e; e = g->first[v1]; @@ -305,27 +306,27 @@ cmph_uint8 cmph_graph_contains_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 return 1; } -cmph_uint32 cmph_graph_vertex_id(cmph_graph_t *g, cmph_uint32 e, cmph_uint32 id) /* included -- Fabiano*/ +cmph_uint32 graph_vertex_id(graph_t *g, cmph_uint32 e, cmph_uint32 id) /* included -- Fabiano*/ { return (g->edges[e + id*g->nedges]); } -cmph_uint32 cmph_graph_ncritical_nodes(cmph_graph_t *g) /* included -- Fabiano*/ +cmph_uint32 graph_ncritical_nodes(graph_t *g) /* included -- Fabiano*/ { return g->ncritical_nodes; } -cmph_graph_iterator_t cmph_graph_neighbors_it(cmph_graph_t *g, cmph_uint32 v) +graph_iterator_t graph_neighbors_it(graph_t *g, cmph_uint32 v) { - cmph_graph_iterator_t it; + graph_iterator_t it; it.vertex = v; it.edge = g->first[v]; return it; } -cmph_uint32 cmph_graph_next_neighbor(cmph_graph_t *g, cmph_graph_iterator_t* it) +cmph_uint32 graph_next_neighbor(graph_t *g, graph_iterator_t* it) { cmph_uint32 ret; - if(it->edge == EMPTY) return CMPH_GRAPH_NO_NEIGHBOR; + if(it->edge == EMPTY) return GRAPH_NO_NEIGHBOR; if (g->edges[it->edge] == it->vertex) ret = g->edges[it->edge + g->nedges]; else ret = g->edges[it->edge]; it->edge = g->next[it->edge]; diff --git a/src/graph.h b/src/graph.h index dc80b05..e1b5de6 100644 --- a/src/graph.h +++ b/src/graph.h @@ -4,11 +4,11 @@ #include #include "cmph_types.h" -#define CMPH_GRAPH_NO_NEIGHBOR UINT_MAX +#define GRAPH_NO_NEIGHBOR UINT_MAX -typedef struct cmph__graph_t cmph_graph_t; -typedef struct cmph__graph_iterator_t cmph_graph_iterator_t; -struct cmph__graph_iterator_t +typedef struct __graph_t graph_t; +typedef struct __graph_iterator_t graph_iterator_t; +struct __graph_iterator_t { cmph_uint32 vertex; cmph_uint32 edge; @@ -16,25 +16,25 @@ struct cmph__graph_iterator_t -cmph_graph_t *cmph_graph_new(cmph_uint32 nnodes, cmph_uint32 nedges); -void cmph_graph_destroy(cmph_graph_t *graph); +graph_t *graph_new(cmph_uint32 nnodes, cmph_uint32 nedges); +void graph_destroy(graph_t *graph); -void cmph_graph_add_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2); -void cmph_graph_del_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2); -void cmph_graph_clear_edges(cmph_graph_t *g); -cmph_uint32 cmph_graph_edge_id(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2); -cmph_uint8 cmph_graph_contains_edge(cmph_graph_t *g, cmph_uint32 v1, cmph_uint32 v2); +void graph_add_edge(graph_t *g, cmph_uint32 v1, cmph_uint32 v2); +void graph_del_edge(graph_t *g, cmph_uint32 v1, cmph_uint32 v2); +void graph_clear_edges(graph_t *g); +cmph_uint32 graph_edge_id(graph_t *g, cmph_uint32 v1, cmph_uint32 v2); +cmph_uint8 graph_contains_edge(graph_t *g, cmph_uint32 v1, cmph_uint32 v2); -cmph_graph_iterator_t cmph_graph_neighbors_it(cmph_graph_t *g, cmph_uint32 v); -cmph_uint32 cmph_graph_next_neighbor(cmph_graph_t *g, cmph_graph_iterator_t* it); +graph_iterator_t graph_neighbors_it(graph_t *g, cmph_uint32 v); +cmph_uint32 graph_next_neighbor(graph_t *g, graph_iterator_t* it); -void cmph_graph_obtain_critical_nodes(cmph_graph_t *g); /* included -- Fabiano*/ -cmph_uint8 cmph_graph_node_is_critical(cmph_graph_t * g, cmph_uint32 v); /* included -- Fabiano */ -cmph_uint32 cmph_graph_ncritical_nodes(cmph_graph_t *g); /* included -- Fabiano*/ -cmph_uint32 cmph_graph_vertex_id(cmph_graph_t *g, cmph_uint32 e, cmph_uint32 id); /* included -- Fabiano*/ +void graph_obtain_critical_nodes(graph_t *g); /* included -- Fabiano*/ +cmph_uint8 graph_node_is_critical(graph_t * g, cmph_uint32 v); /* included -- Fabiano */ +cmph_uint32 graph_ncritical_nodes(graph_t *g); /* included -- Fabiano*/ +cmph_uint32 graph_vertex_id(graph_t *g, cmph_uint32 e, cmph_uint32 id); /* included -- Fabiano*/ -int cmph_graph_is_cyclic(cmph_graph_t *g); +int graph_is_cyclic(graph_t *g); -void cmph_graph_print(cmph_graph_t *); +void graph_print(graph_t *); #endif diff --git a/src/hash.c b/src/hash.c index 639f799..369ea3b 100644 --- a/src/hash.c +++ b/src/hash.c @@ -7,26 +7,26 @@ //#define DEBUG #include "debug.h" -const char *cmph_hash_names[] = { "jenkins", "djb2", "sdbm", "fnv", "glib", "pjw", NULL }; +const char *cmph_hash_names[] = { "djb2", "fnv", "glib", "jenkins", "pjw", "sdbm", NULL }; -cmph_hash_state_t *cmph_hash_state_new(CMPH_HASH hashfunc, cmph_uint32 hashsize) +hash_state_t *hash_state_new(CMPH_HASH hashfunc, cmph_uint32 hashsize) { - cmph_hash_state_t *state = NULL; + hash_state_t *state = NULL; switch (hashfunc) { case CMPH_HASH_JENKINS: DEBUGP("Jenkins function - %u\n", hashsize); - state = (cmph_hash_state_t *)cmph_jenkins_state_new(hashsize); + state = (hash_state_t *)jenkins_state_new(hashsize); DEBUGP("Jenkins function created\n"); break; case CMPH_HASH_DJB2: - state = (cmph_hash_state_t *)cmph_djb2_state_new(); + state = (hash_state_t *)djb2_state_new(); break; case CMPH_HASH_SDBM: - state = (cmph_hash_state_t *)cmph_sdbm_state_new(); + state = (hash_state_t *)sdbm_state_new(); break; case CMPH_HASH_FNV: - state = (cmph_hash_state_t *)cmph_fnv_state_new(); + state = (hash_state_t *)fnv_state_new(); break; default: assert(0); @@ -34,18 +34,18 @@ cmph_hash_state_t *cmph_hash_state_new(CMPH_HASH hashfunc, cmph_uint32 hashsize) state->hashfunc = hashfunc; return state; } -cmph_uint32 cmph_hash(cmph_hash_state_t *state, const char *key, cmph_uint32 keylen) +cmph_uint32 hash(hash_state_t *state, const char *key, cmph_uint32 keylen) { switch (state->hashfunc) { case CMPH_HASH_JENKINS: - return cmph_jenkins_hash((cmph_jenkins_state_t *)state, key, keylen); + return jenkins_hash((jenkins_state_t *)state, key, keylen); case CMPH_HASH_DJB2: - return cmph_djb2_hash((cmph_djb2_state_t *)state, key, keylen); + return djb2_hash((djb2_state_t *)state, key, keylen); case CMPH_HASH_SDBM: - return cmph_sdbm_hash((cmph_sdbm_state_t *)state, key, keylen); + return sdbm_hash((sdbm_state_t *)state, key, keylen); case CMPH_HASH_FNV: - return cmph_fnv_hash((cmph_fnv_state_t *)state, key, keylen); + return fnv_hash((fnv_state_t *)state, key, keylen); default: assert(0); } @@ -53,25 +53,25 @@ cmph_uint32 cmph_hash(cmph_hash_state_t *state, const char *key, cmph_uint32 key return 0; } -void cmph_hash_state_dump(cmph_hash_state_t *state, char **buf, cmph_uint32 *buflen) +void hash_state_dump(hash_state_t *state, char **buf, cmph_uint32 *buflen) { char *algobuf; switch (state->hashfunc) { case CMPH_HASH_JENKINS: - cmph_jenkins_state_dump((cmph_jenkins_state_t *)state, &algobuf, buflen); + jenkins_state_dump((jenkins_state_t *)state, &algobuf, buflen); if (*buflen == UINT_MAX) return; break; case CMPH_HASH_DJB2: - cmph_djb2_state_dump((cmph_djb2_state_t *)state, &algobuf, buflen); + djb2_state_dump((djb2_state_t *)state, &algobuf, buflen); if (*buflen == UINT_MAX) return; break; case CMPH_HASH_SDBM: - cmph_sdbm_state_dump((cmph_sdbm_state_t *)state, &algobuf, buflen); + sdbm_state_dump((sdbm_state_t *)state, &algobuf, buflen); if (*buflen == UINT_MAX) return; break; case CMPH_HASH_FNV: - cmph_fnv_state_dump((cmph_fnv_state_t *)state, &algobuf, buflen); + fnv_state_dump((fnv_state_t *)state, &algobuf, buflen); if (*buflen == UINT_MAX) return; break; default: @@ -86,7 +86,7 @@ void cmph_hash_state_dump(cmph_hash_state_t *state, char **buf, cmph_uint32 *buf return; } -cmph_hash_state_t *cmph_hash_state_load(const char *buf, cmph_uint32 buflen) +hash_state_t *hash_state_load(const char *buf, cmph_uint32 buflen) { cmph_uint32 i; cmph_uint32 offset; @@ -104,33 +104,33 @@ cmph_hash_state_t *cmph_hash_state_load(const char *buf, cmph_uint32 buflen) switch (hashfunc) { case CMPH_HASH_JENKINS: - return (cmph_hash_state_t *)cmph_jenkins_state_load(buf + offset, buflen - offset); + return (hash_state_t *)jenkins_state_load(buf + offset, buflen - offset); case CMPH_HASH_DJB2: - return (cmph_hash_state_t *)cmph_djb2_state_load(buf + offset, buflen - offset); + return (hash_state_t *)djb2_state_load(buf + offset, buflen - offset); case CMPH_HASH_SDBM: - return (cmph_hash_state_t *)cmph_sdbm_state_load(buf + offset, buflen - offset); + return (hash_state_t *)sdbm_state_load(buf + offset, buflen - offset); case CMPH_HASH_FNV: - return (cmph_hash_state_t *)cmph_fnv_state_load(buf + offset, buflen - offset); + return (hash_state_t *)fnv_state_load(buf + offset, buflen - offset); default: return NULL; } return NULL; } -void cmph_hash_state_destroy(cmph_hash_state_t *state) +void hash_state_destroy(hash_state_t *state) { switch (state->hashfunc) { case CMPH_HASH_JENKINS: - cmph_jenkins_state_destroy((cmph_jenkins_state_t *)state); + jenkins_state_destroy((jenkins_state_t *)state); break; case CMPH_HASH_DJB2: - cmph_djb2_state_destroy((cmph_djb2_state_t *)state); + djb2_state_destroy((djb2_state_t *)state); break; case CMPH_HASH_SDBM: - cmph_sdbm_state_destroy((cmph_sdbm_state_t *)state); + sdbm_state_destroy((sdbm_state_t *)state); break; case CMPH_HASH_FNV: - cmph_fnv_state_destroy((cmph_fnv_state_t *)state); + fnv_state_destroy((fnv_state_t *)state); break; default: assert(0); diff --git a/src/hash.h b/src/hash.h index 371c1c9..2397c33 100644 --- a/src/hash.h +++ b/src/hash.h @@ -3,12 +3,12 @@ #include "cmph_types.h" -typedef union cmph__hash_state_t cmph_hash_state_t; +typedef union __hash_state_t hash_state_t; -cmph_hash_state_t *cmph_hash_state_new(CMPH_HASH, cmph_uint32 hashsize); -cmph_uint32 cmph_hash(cmph_hash_state_t *state, const char *key, cmph_uint32 keylen); -void cmph_hash_state_dump(cmph_hash_state_t *state, char **buf, cmph_uint32 *buflen); -cmph_hash_state_t *cmph_hash_state_load(const char *buf, cmph_uint32 buflen); -void cmph_hash_state_destroy(cmph_hash_state_t *state); +hash_state_t *hash_state_new(CMPH_HASH, cmph_uint32 hashsize); +cmph_uint32 hash(hash_state_t *state, const char *key, cmph_uint32 keylen); +void hash_state_dump(hash_state_t *state, char **buf, cmph_uint32 *buflen); +hash_state_t *hash_state_load(const char *buf, cmph_uint32 buflen); +void hash_state_destroy(hash_state_t *state); #endif diff --git a/src/hash_state.h b/src/hash_state.h index 39f0d68..67dcd77 100644 --- a/src/hash_state.h +++ b/src/hash_state.h @@ -6,13 +6,13 @@ #include "djb2_hash.h" #include "sdbm_hash.h" #include "fnv_hash.h" -union cmph__hash_state_t +union __hash_state_t { CMPH_HASH hashfunc; - cmph_jenkins_state_t jenkins; - cmph_djb2_state_t djb2; - cmph_sdbm_state_t sdbm; - cmph_fnv_state_t fnv; + jenkins_state_t jenkins; + djb2_state_t djb2; + sdbm_state_t sdbm; + fnv_state_t fnv; }; #endif diff --git a/src/jenkins_hash.c b/src/jenkins_hash.c index 1971276..c849ec8 100644 --- a/src/jenkins_hash.c +++ b/src/jenkins_hash.c @@ -84,9 +84,9 @@ Use for hash table lookup, or anything where one collision in 2^^32 is acceptable. Do NOT use for cryptographic purposes. -------------------------------------------------------------------- */ -cmph_jenkins_state_t *cmph_jenkins_state_new(cmph_uint32 size) //size of hash table +jenkins_state_t *jenkins_state_new(cmph_uint32 size) //size of hash table { - cmph_jenkins_state_t *state = (cmph_jenkins_state_t *)malloc(sizeof(cmph_jenkins_state_t)); + jenkins_state_t *state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t)); DEBUGP("Initializing jenkins hash\n"); state->seed = rand() % size; state->nbits = (cmph_uint32)ceil(log(size)/M_LOG2E); @@ -94,12 +94,12 @@ cmph_jenkins_state_t *cmph_jenkins_state_new(cmph_uint32 size) //size of hash ta DEBUGP("Initialized jenkins with size %u, nbits %u and seed %u\n", size, state->nbits, state->seed); return state; } -void cmph_jenkins_state_destroy(cmph_jenkins_state_t *state) +void jenkins_state_destroy(jenkins_state_t *state) { free(state); } -cmph_uint32 cmph_jenkins_hash(cmph_jenkins_state_t *state, const char *k, cmph_uint32 keylen) +cmph_uint32 jenkins_hash(jenkins_state_t *state, const char *k, cmph_uint32 keylen) { cmph_uint32 a, b, c; cmph_uint32 len, length; @@ -162,7 +162,7 @@ cmph_uint32 cmph_jenkins_hash(cmph_jenkins_state_t *state, const char *k, cmph_u return c; } -void cmph_jenkins_state_dump(cmph_jenkins_state_t *state, char **buf, cmph_uint32 *buflen) +void jenkins_state_dump(jenkins_state_t *state, char **buf, cmph_uint32 *buflen) { *buflen = sizeof(cmph_uint32)*3; *buf = malloc(*buflen); @@ -178,9 +178,9 @@ void cmph_jenkins_state_dump(cmph_jenkins_state_t *state, char **buf, cmph_uint3 return; } -cmph_jenkins_state_t *cmph_jenkins_state_load(const char *buf, cmph_uint32 buflen) +jenkins_state_t *jenkins_state_load(const char *buf, cmph_uint32 buflen) { - cmph_jenkins_state_t *state = (cmph_jenkins_state_t *)malloc(sizeof(cmph_jenkins_state_t)); + jenkins_state_t *state = (jenkins_state_t *)malloc(sizeof(jenkins_state_t)); state->seed = *(cmph_uint32 *)buf; state->nbits = *(((cmph_uint32 *)buf) + 1); state->size = *(((cmph_uint32 *)buf) + 2); diff --git a/src/jenkins_hash.h b/src/jenkins_hash.h index 2086d7c..baa6209 100644 --- a/src/jenkins_hash.h +++ b/src/jenkins_hash.h @@ -3,18 +3,18 @@ #include "hash.h" -typedef struct cmph__jenkins_state_t +typedef struct __jenkins_state_t { CMPH_HASH hashfunc; cmph_uint32 seed; cmph_uint32 nbits; cmph_uint32 size; -} cmph_jenkins_state_t; +} jenkins_state_t; -cmph_jenkins_state_t *cmph_jenkins_state_new(cmph_uint32 size); //size of hash table -cmph_uint32 cmph_jenkins_hash(cmph_jenkins_state_t *state, const char *k, cmph_uint32 keylen); -void cmph_jenkins_state_dump(cmph_jenkins_state_t *state, char **buf, cmph_uint32 *buflen); -cmph_jenkins_state_t *cmph_jenkins_state_load(const char *buf, cmph_uint32 buflen); -void cmph_jenkins_state_destroy(cmph_jenkins_state_t *state); +jenkins_state_t *jenkins_state_new(cmph_uint32 size); //size of hash table +cmph_uint32 jenkins_hash(jenkins_state_t *state, const char *k, cmph_uint32 keylen); +void jenkins_state_dump(jenkins_state_t *state, char **buf, cmph_uint32 *buflen); +jenkins_state_t *jenkins_state_load(const char *buf, cmph_uint32 buflen); +void jenkins_state_destroy(jenkins_state_t *state); #endif diff --git a/src/main.c b/src/main.c index fcc9d01..21ab419 100644 --- a/src/main.c +++ b/src/main.c @@ -106,8 +106,8 @@ int main(int argc, char **argv) cmph_uint32 i; CMPH_ALGO mph_algo = CMPH_CZECH; float c = 2.09; - cmph_mph_t *mph = NULL; - cmph_mphf_t *mphf = NULL; + cmph_config_t *config = NULL; + cmph_t *mphf = NULL; cmph_key_source_t source; @@ -243,18 +243,18 @@ int main(int argc, char **argv) if (generate) { //Create mphf - - mph = cmph_mph_new(mph_algo, &source); - if (nhashes) cmph_mph_set_hashfuncs(mph, hashes); - cmph_mph_set_verbosity(mph, verbosity); + config = cmph_config_new(&source); + cmph_config_set_algo(config, mph_algo); + if (nhashes) cmph_config_set_hashfuncs(config, hashes); + cmph_config_set_verbosity(config, verbosity); if(mph_algo == CMPH_BMZ && c >= 2.0) c=1.15; - if (c != 0) cmph_mph_set_graphsize(mph, c); - mphf = cmph_mph_create(mph); + if (c != 0) cmph_config_set_graphsize(config, c); + mphf = cmph_new(config); if (mphf == NULL) { fprintf(stderr, "Unable to create minimum perfect hashing function\n"); - cmph_mph_destroy(mph); + cmph_config_destroy(config); free(mphf_file); return -1; } @@ -266,13 +266,13 @@ int main(int argc, char **argv) free(mphf_file); return -1; } - cmph_mphf_dump(mphf, mphf_fd); - cmph_mphf_destroy(mphf); + cmph_dump(mphf, mphf_fd); + cmph_destroy(mphf); fclose(mphf_fd); } else { - cmph_uint8 * hashtable = NULL; + cmph_uint8 * hashtable = NULL; mphf_fd = fopen(mphf_file, "r"); if (mphf_fd == NULL) { @@ -280,7 +280,7 @@ int main(int argc, char **argv) free(mphf_file); return -1; } - mphf = cmph_mphf_load(mphf_fd); + mphf = cmph_load(mphf_fd); fclose(mphf_fd); if (!mphf) { @@ -297,7 +297,7 @@ int main(int argc, char **argv) char *buf; cmph_uint32 buflen = 0; source.read(source.data, &buf, &buflen); - h = cmph_mphf_search(mphf, buf, buflen); + h = cmph_search(mphf, buf, buflen); if(hashtable[h])fprintf(stderr, "collision: %u\n",h); assert(hashtable[h]==0); hashtable[h] = 1; @@ -307,7 +307,7 @@ int main(int argc, char **argv) } source.dispose(source.data, buf, buflen); } - cmph_mphf_destroy(mphf); + cmph_destroy(mphf); free(hashtable); } fclose(keys_fd); diff --git a/src/sdbm_hash.c b/src/sdbm_hash.c index 0a0b8fd..bddcce6 100644 --- a/src/sdbm_hash.c +++ b/src/sdbm_hash.c @@ -1,19 +1,19 @@ #include "sdbm_hash.h" #include -cmph_sdbm_state_t *cmph_sdbm_state_new() +sdbm_state_t *sdbm_state_new() { - cmph_sdbm_state_t *state = (cmph_sdbm_state_t *)malloc(sizeof(cmph_sdbm_state_t)); + sdbm_state_t *state = (sdbm_state_t *)malloc(sizeof(sdbm_state_t)); state->hashfunc = CMPH_HASH_SDBM; return state; } -void cmph_sdbm_state_destroy(cmph_sdbm_state_t *state) +void sdbm_state_destroy(sdbm_state_t *state) { free(state); } -cmph_uint32 cmph_sdbm_hash(cmph_sdbm_state_t *state, const char *k, cmph_uint32 keylen) +cmph_uint32 sdbm_hash(sdbm_state_t *state, const char *k, cmph_uint32 keylen) { register cmph_uint32 hash = 0; const unsigned char *ptr = k; @@ -27,16 +27,16 @@ cmph_uint32 cmph_sdbm_hash(cmph_sdbm_state_t *state, const char *k, cmph_uint32 } -void cmph_sdbm_state_dump(cmph_sdbm_state_t *state, char **buf, cmph_uint32 *buflen) +void sdbm_state_dump(sdbm_state_t *state, char **buf, cmph_uint32 *buflen) { *buf = NULL; *buflen = 0; return; } -cmph_sdbm_state_t *cmph_sdbm_state_load(const char *buf, cmph_uint32 buflen) +sdbm_state_t *sdbm_state_load(const char *buf, cmph_uint32 buflen) { - cmph_sdbm_state_t *state = (cmph_sdbm_state_t *)malloc(sizeof(cmph_sdbm_state_t)); + sdbm_state_t *state = (sdbm_state_t *)malloc(sizeof(sdbm_state_t)); state->hashfunc = CMPH_HASH_SDBM; return state; } diff --git a/src/sdbm_hash.h b/src/sdbm_hash.h index 39cd3bb..a05daae 100644 --- a/src/sdbm_hash.h +++ b/src/sdbm_hash.h @@ -3,15 +3,15 @@ #include "hash.h" -typedef struct cmph__sdbm_state_t +typedef struct __sdbm_state_t { CMPH_HASH hashfunc; -} cmph_sdbm_state_t; +} sdbm_state_t; -cmph_sdbm_state_t *cmph_sdbm_state_new(); -cmph_uint32 cmph_sdbm_hash(cmph_sdbm_state_t *state, const char *k, cmph_uint32 keylen); -void cmph_sdbm_state_dump(cmph_sdbm_state_t *state, char **buf, cmph_uint32 *buflen); -cmph_sdbm_state_t *cmph_sdbm_state_load(const char *buf, cmph_uint32 buflen); -void cmph_sdbm_state_destroy(cmph_sdbm_state_t *state); +sdbm_state_t *sdbm_state_new(); +cmph_uint32 sdbm_hash(sdbm_state_t *state, const char *k, cmph_uint32 keylen); +void sdbm_state_dump(sdbm_state_t *state, char **buf, cmph_uint32 *buflen); +sdbm_state_t *sdbm_state_load(const char *buf, cmph_uint32 buflen); +void sdbm_state_destroy(sdbm_state_t *state); #endif diff --git a/src/vqueue.c b/src/vqueue.c index e893b5b..0e55095 100644 --- a/src/vqueue.c +++ b/src/vqueue.c @@ -2,15 +2,15 @@ #include #include #include -struct cmph__vqueue_t +struct __vqueue_t { cmph_uint32 * values; cmph_uint32 beg, end, capacity; }; -cmph_vqueue_t * cmph_vqueue_new(cmph_uint32 capacity) +vqueue_t * vqueue_new(cmph_uint32 capacity) { - cmph_vqueue_t *q = (cmph_vqueue_t *)malloc(sizeof(cmph_vqueue_t)); + vqueue_t *q = (vqueue_t *)malloc(sizeof(vqueue_t)); assert(q); q->values = (cmph_uint32 *)calloc(capacity+1, sizeof(cmph_uint32)); q->beg = q->end = 0; @@ -18,33 +18,33 @@ cmph_vqueue_t * cmph_vqueue_new(cmph_uint32 capacity) return q; } -cmph_uint8 cmph_vqueue_is_empty(cmph_vqueue_t * q) +cmph_uint8 vqueue_is_empty(vqueue_t * q) { return (q->beg == q->end); } -void cmph_vqueue_insert(cmph_vqueue_t * q, cmph_uint32 val) +void vqueue_insert(vqueue_t * q, cmph_uint32 val) { assert((q->end + 1)%q->capacity != q->beg); // Is queue full? q->end = (q->end + 1)%q->capacity; q->values[q->end] = val; } -cmph_uint32 cmph_vqueue_remove(cmph_vqueue_t * q) +cmph_uint32 vqueue_remove(vqueue_t * q) { - assert(!cmph_vqueue_is_empty(q)); // Is queue empty? + assert(!vqueue_is_empty(q)); // Is queue empty? q->beg = (q->beg + 1)%q->capacity; return q->values[q->beg]; } -void cmph_vqueue_print(cmph_vqueue_t * q) +void vqueue_print(vqueue_t * q) { cmph_uint32 i; for (i = q->beg; i != q->end; i = (i + 1)%q->capacity) fprintf(stderr, "%u\n", q->values[(i + 1)%q->capacity]); } -void cmph_vqueue_destroy(cmph_vqueue_t *q) +void vqueue_destroy(vqueue_t *q) { free(q->values); q->values = NULL; } diff --git a/src/vqueue.h b/src/vqueue.h index d0853a9..86fccab 100644 --- a/src/vqueue.h +++ b/src/vqueue.h @@ -2,17 +2,17 @@ #define __CMPH_VQUEUE_H__ #include "cmph_types.h" -typedef struct cmph__vqueue_t cmph_vqueue_t; +typedef struct __vqueue_t vqueue_t; -cmph_vqueue_t * cmph_vqueue_new(cmph_uint32 capacity); +vqueue_t * vqueue_new(cmph_uint32 capacity); -cmph_uint8 cmph_vqueue_is_empty(cmph_vqueue_t * q); +cmph_uint8 vqueue_is_empty(vqueue_t * q); -void cmph_vqueue_insert(cmph_vqueue_t * q, cmph_uint32 val); +void vqueue_insert(vqueue_t * q, cmph_uint32 val); -cmph_uint32 cmph_vqueue_remove(cmph_vqueue_t * q); +cmph_uint32 vqueue_remove(vqueue_t * q); -void cmph_vqueue_print(cmph_vqueue_t * q); +void vqueue_print(vqueue_t * q); -void cmph_vqueue_destroy(cmph_vqueue_t * q); +void vqueue_destroy(vqueue_t * q); #endif diff --git a/src/vstack.c b/src/vstack.c index a74f667..24555cd 100644 --- a/src/vstack.c +++ b/src/vstack.c @@ -6,16 +6,16 @@ //#define DEBUG #include "debug.h" -struct cmph__vstack_t +struct __vstack_t { cmph_uint32 pointer; cmph_uint32 *values; cmph_uint32 capacity; }; -cmph_vstack_t *cmph_vstack_new() +vstack_t *vstack_new() { - cmph_vstack_t *stack = (cmph_vstack_t *)malloc(sizeof(cmph_vstack_t)); + vstack_t *stack = (vstack_t *)malloc(sizeof(vstack_t)); assert(stack); stack->pointer = 0; stack->values = NULL; @@ -23,43 +23,43 @@ cmph_vstack_t *cmph_vstack_new() return stack; } -void cmph_vstack_destroy(cmph_vstack_t *stack) +void vstack_destroy(vstack_t *stack) { assert(stack); free(stack->values); free(stack); } -void cmph_vstack_push(cmph_vstack_t *stack, cmph_uint32 val) +void vstack_push(vstack_t *stack, cmph_uint32 val) { assert(stack); - cmph_vstack_reserve(stack, stack->pointer + 1); + vstack_reserve(stack, stack->pointer + 1); stack->values[stack->pointer] = val; ++(stack->pointer); } -void cmph_vstack_pop(cmph_vstack_t *stack) +void vstack_pop(vstack_t *stack) { assert(stack); assert(stack->pointer > 0); --(stack->pointer); } -cmph_uint32 cmph_vstack_top(cmph_vstack_t *stack) +cmph_uint32 vstack_top(vstack_t *stack) { assert(stack); assert(stack->pointer > 0); return stack->values[(stack->pointer - 1)]; } -int cmph_vstack_empty(cmph_vstack_t *stack) +int vstack_empty(vstack_t *stack) { assert(stack); return stack->pointer == 0; } -cmph_uint32 cmph_vstack_size(cmph_vstack_t *stack) +cmph_uint32 vstack_size(vstack_t *stack) { return stack->pointer; } -void cmph_vstack_reserve(cmph_vstack_t *stack, cmph_uint32 size) +void vstack_reserve(vstack_t *stack, cmph_uint32 size) { assert(stack); if (stack->capacity < size) diff --git a/src/vstack.h b/src/vstack.h index 8552a43..1cefaaf 100644 --- a/src/vstack.h +++ b/src/vstack.h @@ -2,17 +2,17 @@ #define __CMPH_VSTACK_H__ #include "cmph_types.h" -typedef struct cmph__vstack_t cmph_vstack_t; +typedef struct __vstack_t vstack_t; -cmph_vstack_t *cmph_vstack_new(); -void cmph_vstack_destroy(cmph_vstack_t *stack); +vstack_t *vstack_new(); +void vstack_destroy(vstack_t *stack); -void cmph_vstack_push(cmph_vstack_t *stack, cmph_uint32 val); -cmph_uint32 cmph_vstack_top(cmph_vstack_t *stack); -void cmph_vstack_pop(cmph_vstack_t *stack); -int cmph_vstack_empty(cmph_vstack_t *stack); -cmph_uint32 cmph_vstack_size(cmph_vstack_t *stack); +void vstack_push(vstack_t *stack, cmph_uint32 val); +cmph_uint32 vstack_top(vstack_t *stack); +void vstack_pop(vstack_t *stack); +int vstack_empty(vstack_t *stack); +cmph_uint32 vstack_size(vstack_t *stack); -void cmph_vstack_reserve(cmph_vstack_t *stack, cmph_uint32 size); +void vstack_reserve(vstack_t *stack, cmph_uint32 size); #endif