Algorithm-MinPerfHashTwoLevel
view release on metacpan or search on metacpan
MinPerfHashTwoLevel.xs view on Meta::CPAN
sv_setpvf(error,"unsupported old version '%d' in '%s'", head->variant, file);
return MPH_MOUNT_ERROR_BAD_VERSION;
}
if (head->variant > MAX_VARIANT) {
if (error)
sv_setpvf(error,"unknown version '%d' in '%s'", head->variant, file);
return MPH_MOUNT_ERROR_BAD_VERSION;
}
alignment = sizeof(U64);
if (st.st_size % alignment) {
if (error)
sv_setpvf(error,"file '%s' does not have a size which is a multiple of 16 bytes", file);
return MPH_MOUNT_ERROR_BAD_SIZE;
}
if (
head->table_ofs < head->state_ofs ||
head->key_flags_ofs < head->table_ofs ||
head->val_flags_ofs < head->key_flags_ofs ||
head->str_buf_ofs < head->val_flags_ofs ||
st.st_size < head->str_buf_ofs
) {
if (error)
sv_setpvf(error,"corrupt header offsets in '%s'", file);
return MPH_MOUNT_ERROR_BAD_OFFSETS;
}
if (flags & MPH_F_VALIDATE) {
char *start= ptr;
char *state_pv= start + head->state_ofs;
char *str_buf_start= start + head->str_buf_ofs;
char *str_buf_end= start + st.st_size;
U64 have_file_checksum= mph_hash_with_state(state_pv, start, st.st_size - sizeof(U64));
U64 want_file_checksum= *((U64 *)(str_buf_end - sizeof(U64)));
if (have_file_checksum != want_file_checksum) {
if (error)
sv_setpvf(error,"file checksum '%016lx' != '%016lx' in file '%s'",
have_file_checksum,want_file_checksum,file);
return MPH_MOUNT_ERROR_CORRUPT_FILE;
}
}
return head->variant;
}
void
mph_munmap(struct mph_obj *obj) {
munmap(obj->header,obj->bytes);
}
STRLEN
normalize_with_flags(pTHX_ SV *sv, SV *normalized_sv, SV *is_utf8_sv, int downgrade) {
STRLEN len;
if (SvROK(sv)) {
croak("Error: Not expecting a reference value in source hash");
}
sv_setsv(normalized_sv,sv);
if (SvOK(sv)) {
STRLEN pv_len;
char *pv= SvPV(sv,pv_len);
if (pv_len > 0xFFFF)
croak("Error: String in source hash is too long to store, max length is %u got length %lu", 0xFFFF, pv_len);
if (SvUTF8(sv)) {
if (downgrade)
sv_utf8_downgrade(normalized_sv,1);
if (SvUTF8(normalized_sv)) {
SvUTF8_off(normalized_sv);
sv_setiv(is_utf8_sv,1);
} else {
sv_setiv(is_utf8_sv,2);
}
}
return pv_len;
} else {
sv_setiv(is_utf8_sv, 0);
return 0;
}
}
U32
_roundup(const U32 n, const U32 s) {
const U32 r= n % s;
if (r) {
return n + s - r;
} else {
return n;
}
}
START_MY_CXT
I32
_compare(pTHX_ SV *a, SV *b) {
dMY_CXT;
HE *a_he= hv_fetch_ent_with_keysv((HV*)SvRV(a),MPH_KEYSV_KEY_NORMALIZED,0);
HE *b_he= hv_fetch_ent_with_keysv((HV*)SvRV(b),MPH_KEYSV_KEY_NORMALIZED,0);
return sv_cmp(HeVAL(a_he),HeVAL(b_he));
}
U32
normalize_source_hash(pTHX_ HV *source_hv, AV *keys_av, U32 compute_flags, SV *buf_length_sv, char *state_pv) {
dMY_CXT;
HE *he;
U32 buf_length= 0;
U32 ctr;
hv_iterinit(source_hv);
while (he= hv_iternext(source_hv)) {
SV *val_sv= HeVAL(he);
SV *val_normalized_sv;
SV *val_is_utf8_sv;
SV *key_sv;
SV *key_normalized_sv;
SV *key_is_utf8_sv;
HV *hv;
U8 *key_pv;
STRLEN key_len;
U64 h0;
if (!val_sv) croak("panic: no sv for value?");
if (!SvOK(val_sv) && (compute_flags & MPH_F_FILTER_UNDEF)) continue;
hv= newHV();
val_normalized_sv= newSV(0);
val_is_utf8_sv= newSVuv(0);
key_sv= newSVhek(HeKEY_hek(he));
key_normalized_sv= newSV(0);
key_is_utf8_sv= newSVuv(0);
hv_ksplit(hv,15);
hv_store_ent_with_keysv(hv,MPH_KEYSV_KEY, key_sv);
hv_store_ent_with_keysv(hv,MPH_KEYSV_KEY_NORMALIZED, key_normalized_sv);
hv_store_ent_with_keysv(hv,MPH_KEYSV_KEY_IS_UTF8, key_is_utf8_sv);
hv_store_ent_with_keysv(hv,MPH_KEYSV_VAL, SvREFCNT_inc_simple_NN(val_sv));
hv_store_ent_with_keysv(hv,MPH_KEYSV_VAL_NORMALIZED, val_normalized_sv);
hv_store_ent_with_keysv(hv,MPH_KEYSV_VAL_IS_UTF8, val_is_utf8_sv);
/* install everything into the keys_av just in case normalize_with_flags() dies */
av_push(keys_av,newRV_noinc((SV*)hv));
buf_length += normalize_with_flags(aTHX_ key_sv, key_normalized_sv, key_is_utf8_sv, 1);
buf_length += normalize_with_flags(aTHX_ val_sv, val_normalized_sv, val_is_utf8_sv, 0);
key_pv= (U8 *)SvPV(key_normalized_sv,key_len);
h0= mph_hash_with_state(state_pv,key_pv,key_len);
hv_store_ent_with_keysv(hv,MPH_KEYSV_H0, newSVuv(h0));
}
if (buf_length_sv)
sv_setuv(buf_length_sv, buf_length);
/* we now know how many keys there are, and what the max_xor_val should be */
return av_top_index(keys_av)+1;
}
void
find_first_level_collisions(pTHX_ U32 bucket_count, AV *keys_av, AV *keybuckets_av, AV *h2_packed_av) {
dMY_CXT;
U32 i;
for (i=0; i<bucket_count;i++) {
U64 h0;
U32 h1;
U32 h2;
U32 idx1;
SV **got_psv;
SV* h0_sv;
HE* h0_he;
HV *hv;
AV *av;
got_psv= av_fetch(keys_av,i,0);
if (!got_psv || !SvROK(*got_psv)) croak("panic: bad item in keys_av");
hv= (HV *)SvRV(*got_psv);
h0_he= hv_fetch_ent_with_keysv(hv,MPH_KEYSV_H0,0);
if (!h0_he) croak("panic: no h0_he?");
h0_sv= HeVAL(h0_he);
h0= SvUV(h0_sv);
h1= h0 >> 32;
h2= h0 & 0xFFFFFFFF;
idx1= h1 % bucket_count;
got_psv= av_fetch(h2_packed_av,idx1,1);
if (!got_psv)
croak("panic: out of memory creating new h2_packed_av element");
if (!SvPOK(*got_psv))
sv_setpvs(*got_psv,"");
sv_catpvn(*got_psv, (char *)&h2, 4);
got_psv= av_fetch(keybuckets_av,idx1,1);
if (!got_psv)
croak("panic: out of memory creating new keybuckets_av element");
if (!SvROK(*got_psv)) {
av= newAV();
sv_upgrade(*got_psv,SVt_RV);
SvRV_set(*got_psv,(SV *)av);
SvROK_on(*got_psv);
} else {
av= (AV *)SvRV(*got_psv);
}
av_push(av,newRV_inc((SV*)hv));
}
}
AV *
idx_by_length(pTHX_ AV *keybuckets_av) {
U32 i;
U32 keybuckets_count= av_top_index(keybuckets_av) + 1;
AV *by_length_av= (AV*)sv_2mortal((SV*)newAV());
for( i = 0 ; i < keybuckets_count ; i++ ) {
SV **got= av_fetch(keybuckets_av,i,0);
AV *keys_av;
SV *keys_ref;
AV *target_av;
IV len;
if (!got) continue;
keys_av= (AV *)SvRV(*got);
len= av_top_index(keys_av) + 1;
if (len<1) continue;
got= av_fetch(by_length_av,len,1);
if (SvPOK(*got)) {
sv_catpvn(*got,(char *)&i,4);
} else {
sv_setpvn(*got,(char *)&i,4);
}
}
return by_length_av;
}
void set_xor_val_in_buckets(pTHX_ U32 xor_val, AV *buckets_av, U32 idx1, U32 *idx_start, char *is_used, AV *keys_in_bucket_av) {
dMY_CXT;
U32 *idx2;
HV *idx1_hv;
U32 i;
U32 keys_in_bucket_count= av_top_index(keys_in_bucket_av) + 1;
SV **buckets_rvp= av_fetch(buckets_av, idx1, 1);
if (!buckets_rvp) croak("panic: out of memory in buckets_av lvalue fetch");
if (!SvROK(*buckets_rvp)) {
idx1_hv= newHV();
if (!idx1_hv) croak("panic: out of memory creating new hash in buckets_av idx %u",idx1);
sv_upgrade(*buckets_rvp,SVt_RV);
SvRV_set(*buckets_rvp,(SV *)idx1_hv);
SvROK_on(*buckets_rvp);
} else {
idx1_hv= (HV *)SvRV(*buckets_rvp);
}
hv_setuv_with_keysv(idx1_hv,MPH_KEYSV_XOR_VAL,xor_val);
hv_setuv_with_keysv(idx1_hv,MPH_KEYSV_H1_KEYS,keys_in_bucket_count);
/* update used */
for (i= 0, idx2= idx_start; i < keys_in_bucket_count; i++,idx2++) {
HV *idx2_hv;
HV *keys_hv;
SV **keys_rvp;
SV **buckets_rvp;
keys_rvp= av_fetch(keys_in_bucket_av, i, 0);
if (!keys_rvp) croak("panic: no key_info in bucket %d", i);
keys_hv= (HV *)SvRV(*keys_rvp);
buckets_rvp= av_fetch(buckets_av, *idx2, 1);
if (!buckets_rvp) croak("panic: out of memory in lvalue fetch to buckets_av");
if (!SvROK(*buckets_rvp)) {
sv_upgrade(*buckets_rvp,SVt_RV);
} else {
idx2_hv= (HV *)SvRV(*buckets_rvp);
hv_copy_with_keysv(idx2_hv,keys_hv,MPH_KEYSV_XOR_VAL);
hv_copy_with_keysv(idx2_hv,keys_hv,MPH_KEYSV_H1_KEYS);
SvREFCNT_dec(idx2_hv);
}
SvRV_set(*buckets_rvp,(SV*)keys_hv);
SvROK_on(*buckets_rvp);
SvREFCNT_inc(keys_hv);
hv_setuv_with_keysv(keys_hv,MPH_KEYSV_IDX,*idx2);
is_used[*idx2] = 1;
}
}
U32
MinPerfHashTwoLevel.xs view on Meta::CPAN
return idx1 + 1;
} else {
xor_val++;
}
while (h2_ptr < h2_end) {
U32 idx2;
U32 *check_idx;
HASH2INDEX(idx2,*h2_ptr,xor_val,bucket_count);
if (is_used[idx2])
goto next_xor_val;
for (check_idx= idx2_start; check_idx < idx2_ptr; check_idx++) {
if (*check_idx == idx2)
goto next_xor_val;
}
*idx2_ptr= idx2;
h2_ptr++;
idx2_ptr++;
}
break;
}
set_xor_val_in_buckets(aTHX_ xor_val, buckets_av, idx1, idx2_start, is_used, keys_in_bucket_av);
}
return 0;
}
U32
place_singletons(pTHX_ U32 bucket_count, SV *idx1_packed_sv, AV *keybuckets_av, char *is_used, U32 *idx2_start, AV *buckets_av) {
STRLEN idx1_packed_sv_len;
U32 *idx1_start= (U32 *)SvPV(idx1_packed_sv,idx1_packed_sv_len);
U32 *idx1_ptr;
U32 *idx1_end= idx1_start + (idx1_packed_sv_len / sizeof(U32));
U32 singleton_pos= 0;
for (idx1_ptr= idx1_start; idx1_ptr < idx1_end; idx1_ptr++) {
U32 idx1= *idx1_ptr;
AV *keys_in_bucket_av;
U32 xor_val;
SV **got;
while (singleton_pos < bucket_count && is_used[singleton_pos]) {
singleton_pos++;
}
if (singleton_pos == bucket_count) {
warn("failed to place singleton! idx: %d",idx1);
return idx1 + 1;
}
xor_val= (U32)(-singleton_pos-1);
got= av_fetch(keybuckets_av, idx1, 0);
if (!got)
croak("panic: no keybuckets_av for idx %u",idx1);
keys_in_bucket_av= (AV *)SvRV(*got);
*idx2_start= singleton_pos;
set_xor_val_in_buckets(aTHX_ xor_val, buckets_av, idx1, idx2_start, is_used, keys_in_bucket_av);
}
return 0;
}
U32
solve_collisions_by_length(pTHX_ U32 bucket_count, U32 max_xor_val, AV *by_length_av, AV *h2_packed_av, AV *keybuckets_av, U32 variant, AV *buckets_av) {
U32 bad_idx= 0;
I32 singleton_pos= 0;
IV len_idx;
char *is_used;
U32 *idx2_start;
/* this is used to quickly tell if we have used a particular bucket yet */
Newxz(is_used,bucket_count,char);
SAVEFREEPV(is_used);
/* used to keep track the indexes that a set of keys map into
* stored in an SV just because - we actually treat it as an array of U32 */
Newxz(idx2_start, av_top_index(by_length_av)+1, U32);
SAVEFREEPV(idx2_start);
/* now loop through and process the keysets from most collisions to least */
for (len_idx= av_top_index(by_length_av); len_idx > 0 && !bad_idx; len_idx--) {
SV **idx1_packed_sv= av_fetch(by_length_av, len_idx, 0);
/* deal with the possibility that there are gaps in the length grouping,
* for instance we might have some 13 way collisions and some 11 way collisions
* without any 12-way collisions. (this should be rare - but is possible) */
if (!idx1_packed_sv || !SvPOK(*idx1_packed_sv))
continue;
if (len_idx == 1) {
bad_idx= place_singletons(aTHX_ bucket_count, *idx1_packed_sv, keybuckets_av,
is_used, idx2_start, buckets_av);
} else {
bad_idx= solve_collisions(aTHX_ bucket_count, max_xor_val, *idx1_packed_sv, h2_packed_av, keybuckets_av,
variant, is_used, idx2_start, buckets_av);
}
}
return bad_idx;
}
#define MY_CXT_KEY "Algorithm::MinPerfHashTwoLevel::_stash" XS_VERSION
#define SETOFS(i,he,table,key_ofs,key_len,str_buf_start,str_buf_pos,str_buf_end,str_ofs_hv) \
STMT_START { \
if (he) { \
SV *sv= HeVAL(he); \
if (SvOK(sv)) { \
STRLEN pv_len; \
char *pv; \
SV *ofs_sv; \
if (flags & MPH_F_NO_DEDUPE) { \
ofs_sv= NULL; \
} else { \
HE *ofs= hv_fetch_ent(str_ofs_hv,sv,1,0); \
ofs_sv= ofs ? HeVAL(ofs) : NULL; \
if (!ofs_sv) \
croak("panic: out of memory getting str ofs for " #he "for %u",i); \
} \
if (ofs_sv && SvOK(ofs_sv)){ \
table[i].key_ofs= SvUV(ofs_sv); \
table[i].key_len= sv_len(sv); \
} else { \
pv= SvPV(sv,pv_len); \
table[i].key_len= pv_len; \
if (pv_len) { \
table[i].key_ofs= str_buf_pos - str_buf_start; \
if (str_buf_pos + pv_len > str_buf_end) \
croak("panic: string buffer too small in SETOFS, something went horribly wrong."); \
Copy(pv,str_buf_pos,pv_len,char); \
str_buf_pos += pv_len; \
} else { \
table[i].key_ofs= 1; \
} \
if (ofs_sv) \
sv_setuv(ofs_sv,table[i].key_ofs); \
} \
} else { \
table[i].key_ofs= 0; \
table[i].key_len= 0; \
} \
} else { \
croak("no " #he " for %u",i); \
} \
} STMT_END
MinPerfHashTwoLevel.xs view on Meta::CPAN
croak("Error: seed should not be a reference");
seed_sv= base_seed_sv;
seed_pv= (U8 *)SvPV(seed_sv,seed_len);
if (seed_len != MPH_SEED_BYTES) {
if (SvREADONLY(base_seed_sv)) {
if (seed_len < MPH_SEED_BYTES) {
warn("seed passed into seed_state() is readonly and too short, argument has been right padded with %d nulls",
(int)(MPH_SEED_BYTES - seed_len));
}
else if (seed_len > MPH_SEED_BYTES) {
warn("seed passed into seed_state() is readonly and too long, using only the first %d bytes",
(int)MPH_SEED_BYTES);
}
seed_sv= sv_2mortal(newSVsv(base_seed_sv));
}
if (seed_len < MPH_SEED_BYTES) {
sv_grow(seed_sv,MPH_SEED_BYTES+1);
while (seed_len < MPH_SEED_BYTES) {
seed_pv[seed_len] = 0;
seed_len++;
}
}
SvCUR_set(seed_sv,MPH_SEED_BYTES);
seed_pv= (U8 *)SvPV(seed_sv,seed_len);
} else {
seed_sv= base_seed_sv;
}
RETVAL= newSV(MPH_STATE_BYTES+1);
SvCUR_set(RETVAL,MPH_STATE_BYTES);
SvPOK_on(RETVAL);
state_pv= (U8 *)SvPV(RETVAL,state_len);
mph_seed_state(seed_pv,state_pv);
}
OUTPUT:
RETVAL
UV
compute_xs(self_hv)
HV *self_hv
PREINIT:
dMY_CXT;
PROTOTYPE: \%\@
CODE:
{
U8 *state_pv;
STRLEN state_len;
HE *he;
IV len_idx;
U32 bucket_count;
U32 max_xor_val;
U32 i;
U32 variant;
U32 compute_flags;
SV* buf_length_sv;
HV* source_hv;
AV *buckets_av;
AV *keys_av;
AV *by_length_av;
AV *keybuckets_av;
AV *h2_packed_av;
RETVAL = 0;
/**** extract the various reference data we need from $self */
he= hv_fetch_ent_with_keysv(self_hv,MPH_KEYSV_VARIANT,0);
if (he) {
variant= SvUV(HeVAL(he));
} else {
croak("panic: no variant in self?");
}
he= hv_fetch_ent_with_keysv(self_hv,MPH_KEYSV_COMPUTE_FLAGS,0);
if (he) {
compute_flags= SvUV(HeVAL(he));
} else {
croak("panic: no compute_flags in self?");
}
he= hv_fetch_ent_with_keysv(self_hv,MPH_KEYSV_STATE,0);
if (he) {
SV *state_sv= HeVAL(he);
state_pv= (U8 *)SvPV(state_sv,state_len);
if (state_len != MPH_STATE_BYTES) {
croak("Error: state vector must be at exactly %d bytes",(int)MPH_SEED_BYTES);
}
} else {
croak("panic: no state in self?");
}
he= hv_fetch_ent_with_keysv(self_hv,MPH_KEYSV_BUF_LENGTH,1);
if (he) {
buf_length_sv= HeVAL(he);
} else {
croak("panic: out of memory in lvalue fetch for 'buf_length' in self");
}
he= hv_fetch_ent_with_keysv(self_hv,MPH_KEYSV_SOURCE_HASH,0);
if (he) {
source_hv= (HV*)SvRV(HeVAL(he));
} else {
croak("panic: no source_hash in self");
}
he= hv_fetch_ent_with_keysv(self_hv,MPH_KEYSV_BUCKETS,1);
if (he) {
SV *rv= HeVAL(he);
if (SvROK(rv)) {
AV *old_buckets_av= (AV*)SvRV(rv);
SvREFCNT_dec(old_buckets_av);
} else {
sv_upgrade(rv, SVt_RV);
}
buckets_av= newAV();
SvRV_set(rv,(SV*)buckets_av);
SvROK_on(rv);
} else {
croak("panic: out of memory in lvalue fetch for 'buckets' in self");
}
/**** build an array of hashes in keys_av based on the normalized contents of source_hv */
keys_av= (AV *)sv_2mortal((SV*)newAV());
bucket_count= normalize_source_hash(aTHX_ source_hv, keys_av, compute_flags, buf_length_sv, state_pv);
max_xor_val= INT32_MAX;
/* if the caller wants deterministic results we sort the keys_av
* before we compute collisions - depending on the order we process
* the keys we might resolve the collisions differently */
if (compute_flags & MPH_F_DETERMINISTIC)
sortsv(AvARRAY(keys_av),bucket_count,_compare);
/**** find the collisions from the data we just computed, build an AoAoH and AoS of the
**** collision data */
keybuckets_av= (AV*)sv_2mortal((SV*)newAV()); /* AoAoH - hashes from keys_av */
h2_packed_av= (AV*)sv_2mortal((SV*)newAV()); /* AoS - packed h1 */
find_first_level_collisions(aTHX_ bucket_count, keys_av, keybuckets_av, h2_packed_av);
/* Sort the buckets by size by constructing an AoS, with the outer array indexed by length,
* and the inner string being the list of items of that length. (Thus the contents of index
* 0 is empty/undef).
* The end result is we can process the collisions from the most keys to a bucket to the
* least in O(N) and not O(N log2 N).
*
* the length of the array (av_top_index+1) reflect the number of items in the bucket
* with the most collisions - we use this later to size some of our data structures.
*/
by_length_av= idx_by_length(aTHX_ keybuckets_av);
RETVAL= solve_collisions_by_length(aTHX_ bucket_count, max_xor_val, by_length_av, h2_packed_av, keybuckets_av,
variant, buckets_av);
}
OUTPUT:
RETVAL
MODULE = Algorithm::MinPerfHashTwoLevel PACKAGE = Tie::Hash::MinPerfHashTwoLevel::OnDisk
SV *
packed_xs(variant,buf_length_sv,state_sv,comment_sv,flags,buckets_av)
U32 variant
SV* buf_length_sv
SV* state_sv
SV* comment_sv
AV *buckets_av
U32 flags
PREINIT:
dMY_CXT;
PROTOTYPE: $$$$$\@
CODE:
{
U32 buf_length= SvUV(buf_length_sv);
U32 bucket_count= av_top_index(buckets_av) + 1;
U32 header_rlen= _roundup(sizeof(struct mph_header),16);
STRLEN state_len;
char *state_pv= SvPV(state_sv, state_len);
U32 alignment= sizeof(U64);
U32 state_rlen= _roundup(state_len,alignment);
U32 table_rlen= _roundup(sizeof(struct mph_bucket) * bucket_count,alignment);
U32 key_flags_rlen= _roundup((bucket_count * 2 + 7 ) / 8,alignment);
U32 val_flags_rlen= _roundup((bucket_count + 7) / 8,alignment);
U32 str_rlen= _roundup( buf_length
+ 2
+ ( SvOK(comment_sv) ? sv_len(comment_sv) + 1 : 1 )
+ ( 2 + 8 ),
alignment );
U32 total_size;
HV *str_ofs_hv= (HV *)sv_2mortal((SV*)newHV());
SV *sv_buf;
char *start;
struct mph_header *head;
char *state;
struct mph_bucket *table;
char *key_flags;
char *val_flags;
char *str_buf_start;
char *str_buf_end;
char *str_buf_pos;
U32 i;
STRLEN pv_len;
char *pv;
U32 key_is_utf8_count[3]={0,0,0};
U32 val_is_utf8_count[2]={0,0};
U32 used_flags;
U32 the_flag;
IV key_is_utf8_generic=-1;
IV val_is_utf8_generic=-1;
for (i= 0; i < bucket_count; i++) {
SV **got= av_fetch(buckets_av,i,0);
HV *hv= (HV *)SvRV(*got);
HE *key_is_utf8_he= hv_fetch_ent_with_keysv(hv,MPH_KEYSV_KEY_IS_UTF8,0);
HE *val_is_utf8_he= hv_fetch_ent_with_keysv(hv,MPH_KEYSV_VAL_IS_UTF8,0);
key_is_utf8_count[SvUV(HeVAL(key_is_utf8_he))]++;
val_is_utf8_count[SvUV(HeVAL(val_is_utf8_he))]++;
}
used_flags= 0;
if (key_is_utf8_count[0]) { the_flag= 0; used_flags++; }
if (key_is_utf8_count[1]) { the_flag= 1; used_flags++; }
if (key_is_utf8_count[2]) { the_flag= 2; used_flags++; }
if (used_flags == 1) {
key_is_utf8_generic= the_flag;
key_flags_rlen= 0;
}
used_flags= 0;
if (val_is_utf8_count[0]) { the_flag= 0; used_flags++; }
if (val_is_utf8_count[1]) { the_flag= 1; used_flags++; }
if (used_flags == 1) {
val_is_utf8_generic= the_flag;
val_flags_rlen= 0;
}
total_size=
+ header_rlen
+ state_rlen
+ table_rlen
+ key_flags_rlen
+ val_flags_rlen
+ str_rlen
;
( run in 0.831 second using v1.01-cache-2.11-cpan-119454b85a5 )