/** \fn void bmz8_pack(cmph_t *mphf, void *packed_mphf); * \brief Support the ability to pack a perfect hash function into a preallocated contiguous memory space pointed by packed_mphf. * \param mphf pointer to the resulting mphf * \param packed_mphf pointer to the contiguous memory area used to store the resulting mphf. The size of packed_mphf must be at least cmph_packed_size() */ void bmz8_pack(cmph_t *mphf, void *packed_mphf) { bmz8_data_t *data = (bmz8_data_t *)mphf->data; cmph_uint8 * ptr = (cmph_uint8 *)packed_mphf; // packing h1 type CMPH_HASH h1_type = hash_get_type(data->hashes[0]); *((cmph_uint32 *) ptr) = h1_type; ptr += sizeof(cmph_uint32); // packing h1 hash_state_pack(data->hashes[0], ptr); ptr += hash_state_packed_size(h1_type); // packing h2 type CMPH_HASH h2_type = hash_get_type(data->hashes[1]); *((cmph_uint32 *) ptr) = h2_type; ptr += sizeof(cmph_uint32); // packing h2 hash_state_pack(data->hashes[1], ptr); ptr += hash_state_packed_size(h2_type); // packing n *ptr++ = data->n; // packing g memcpy(ptr, data->g, sizeof(cmph_uint8)*data->n); }
void chd_ph_pack(cmph_t *mphf, void *packed_mphf) { chd_ph_data_t *data = (chd_ph_data_t *)mphf->data; cmph_uint8 * ptr = packed_mphf; // packing hl type CMPH_HASH hl_type = hash_get_type(data->hl); *((cmph_uint32 *) ptr) = hl_type; ptr += sizeof(cmph_uint32); // packing hl hash_state_pack(data->hl, ptr); ptr += hash_state_packed_size(hl_type); // packing n *((cmph_uint32 *) ptr) = data->n; ptr += sizeof(data->n); // packing nbuckets *((cmph_uint32 *) ptr) = data->nbuckets; ptr += sizeof(data->nbuckets); // packing cs compressed_seq_pack(data->cs, ptr); //ptr += compressed_seq_packed_size(data->cs); }
/** \fn void fch_pack(cmph_t *mphf, void *packed_mphf); * \brief Support the ability to pack a perfect hash function into a preallocated contiguous memory space pointed by packed_mphf. * \param mphf pointer to the resulting mphf * \param packed_mphf pointer to the contiguous memory area used to store the resulting mphf. The size of packed_mphf must be at least cmph_packed_size() */ void fch_pack(cmph_t *mphf, void *packed_mphf) { fch_data_t *data = (fch_data_t *)mphf->data; cmph_uint8 * ptr = packed_mphf; // packing h1 type CMPH_HASH h1_type = hash_get_type(data->h1); CMPH_HASH h2_type; *((cmph_uint32 *) ptr) = h1_type; ptr += sizeof(cmph_uint32); // packing h1 hash_state_pack(data->h1, ptr); ptr += hash_state_packed_size(h1_type); // packing h2 type h2_type = hash_get_type(data->h2); *((cmph_uint32 *) ptr) = h2_type; ptr += sizeof(cmph_uint32); // packing h2 hash_state_pack(data->h2, ptr); ptr += hash_state_packed_size(h2_type); // packing m *((cmph_uint32 *) ptr) = data->m; ptr += sizeof(data->m); // packing b *((cmph_uint32 *) ptr) = data->b; ptr += sizeof(data->b); // packing p1 *((cmph_uint64 *)ptr) = (cmph_uint64)data->p1; ptr += sizeof(data->p1); // packing p2 *((cmph_uint64 *)ptr) = (cmph_uint64)data->p2; ptr += sizeof(data->p2); // packing g memcpy(ptr, data->g, sizeof(cmph_uint32)*(data->b)); }
/** \fn void brz_pack(cmph_t *mphf, void *packed_mphf); * \brief Support the ability to pack a perfect hash function into a preallocated contiguous memory space pointed by packed_mphf. * \param mphf pointer to the resulting mphf * \param packed_mphf pointer to the contiguous memory area used to store the resulting mphf. The size of packed_mphf must be at least cmph_packed_size() */ void brz_pack(cmph_t *mphf, void *packed_mphf) { brz_data_t *data = (brz_data_t *)mphf->data; cmph_uint8 * ptr = packed_mphf; cmph_uint32 i,n; // packing internal algo type memcpy(ptr, &(data->algo), sizeof(data->algo)); ptr += sizeof(data->algo); // packing h0 type CMPH_HASH h0_type = hash_get_type(data->h0); memcpy(ptr, &h0_type, sizeof(h0_type)); ptr += sizeof(h0_type); // packing h0 hash_state_pack(data->h0, ptr); ptr += hash_state_packed_size(h0_type); // packing k memcpy(ptr, &(data->k), sizeof(data->k)); ptr += sizeof(data->k); // packing c *((cmph_uint64 *)ptr) = (cmph_uint64)data->c; ptr += sizeof(data->c); // packing h1 type CMPH_HASH h1_type = hash_get_type(data->h1[0]); memcpy(ptr, &h1_type, sizeof(h1_type)); ptr += sizeof(h1_type); // packing h2 type CMPH_HASH h2_type = hash_get_type(data->h2[0]); memcpy(ptr, &h2_type, sizeof(h2_type)); ptr += sizeof(h2_type); // packing size memcpy(ptr, data->size, sizeof(cmph_uint8)*data->k); ptr += data->k; // packing offset memcpy(ptr, data->offset, sizeof(cmph_uint32)*data->k); ptr += sizeof(cmph_uint32)*data->k; #if defined (__ia64) || defined (__x86_64__) cmph_uint64 * g_is_ptr = (cmph_uint64 *)ptr; #else cmph_uint32 * g_is_ptr = (cmph_uint32 *)ptr; #endif cmph_uint8 * g_i = (cmph_uint8 *) (g_is_ptr + data->k); for(i = 0; i < data->k; i++) { #if defined (__ia64) || defined (__x86_64__) *g_is_ptr++ = (cmph_uint64)g_i; #else *g_is_ptr++ = (cmph_uint32)g_i; #endif // packing h1[i] hash_state_pack(data->h1[i], g_i); g_i += hash_state_packed_size(h1_type); // packing h2[i] hash_state_pack(data->h2[i], g_i); g_i += hash_state_packed_size(h2_type); // packing g_i switch(data->algo) { case CMPH_FCH: n = fch_calc_b(data->c, data->size[i]); break; case CMPH_BMZ8: n = (cmph_uint32)ceil(data->c * data->size[i]); break; default: assert(0); } memcpy(g_i, data->g[i], sizeof(cmph_uint8)*n); g_i += n; } }