cmph_uint32 chd_ph_packed_size(cmph_t *mphf) { register chd_ph_data_t *data = (chd_ph_data_t *)mphf->data; register CMPH_HASH hl_type = hash_get_type(data->hl); register cmph_uint32 hash_state_pack_size = hash_state_packed_size(hl_type); register cmph_uint32 cs_pack_size = compressed_seq_packed_size(data->cs); return (cmph_uint32)(sizeof(CMPH_ALGO) + hash_state_pack_size + cs_pack_size + 3*sizeof(cmph_uint32)); }
/** \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_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 CMPH_HASH 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 cmph_uint32 brz_packed_size(cmph_t *mphf); * \brief Return the amount of space needed to pack mphf. * \param mphf pointer to a mphf * \return the size of the packed function or zero for failures */ cmph_uint32 brz_packed_size(cmph_t *mphf) { cmph_uint32 i; cmph_uint32 size = 0; brz_data_t *data = (brz_data_t *)mphf->data; CMPH_HASH h0_type = hash_get_type(data->h0); CMPH_HASH h1_type = hash_get_type(data->h1[0]); CMPH_HASH h2_type = hash_get_type(data->h2[0]); size = (cmph_uint32)(2*sizeof(CMPH_ALGO) + 3*sizeof(CMPH_HASH) + hash_state_packed_size(h0_type) + sizeof(cmph_uint32) + sizeof(double) + sizeof(cmph_uint8)*data->k + sizeof(cmph_uint32)*data->k); // pointers to g_is #if defined (__ia64) || defined (__x86_64__) size += (cmph_uint32) sizeof(cmph_uint64)*data->k; #else size += (cmph_uint32) sizeof(cmph_uint32)*data->k; #endif size += hash_state_packed_size(h1_type) * data->k; size += hash_state_packed_size(h2_type) * data->k; cmph_uint32 n = 0; for(i = 0; i < data->k; 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); } size += n; } return size; }
/** \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; } }