HEK *
Perl_hek_dup(pTHX_ HEK *source, CLONE_PARAMS* param)
{
- HE *shared = (HE*)ptr_table_fetch(PL_shared_hek_table, source);
+ HEK *shared = (HEK*)ptr_table_fetch(PL_ptr_table, source);
(void)param;
if (shared) {
/* We already shared this hash key. */
- ++HeVAL(shared);
+ share_hek_hek(shared);
}
else {
- shared = share_hek_flags(HEK_KEY(source), HEK_LEN(source),
- HEK_HASH(source), HEK_FLAGS(source));
- ptr_table_store(PL_shared_hek_table, source, shared);
+ shared
+ = share_hek_flags(HEK_KEY(source), HEK_LEN(source),
+ HEK_HASH(source), HEK_FLAGS(source));
+ ptr_table_store(PL_ptr_table, source, shared);
}
- return HeKEY_hek(shared);
+ return shared;
}
HE *
/* This is hek_dup inlined, which seems to be important for speed
reasons. */
HEK *source = HeKEY_hek(e);
- HE *shared = (HE*)ptr_table_fetch(PL_shared_hek_table, source);
+ HEK *shared = (HEK*)ptr_table_fetch(PL_ptr_table, source);
if (shared) {
/* We already shared this hash key. */
- ++HeVAL(shared);
+ share_hek_hek(shared);
}
else {
- shared = share_hek_flags(HEK_KEY(source), HEK_LEN(source),
- HEK_HASH(source), HEK_FLAGS(source));
- ptr_table_store(PL_shared_hek_table, source, shared);
+ shared
+ = share_hek_flags(HEK_KEY(source), HEK_LEN(source),
+ HEK_HASH(source), HEK_FLAGS(source));
+ ptr_table_store(PL_ptr_table, source, shared);
}
- HeKEY_hek(ret) = HeKEY_hek(shared);
+ HeKEY_hek(ret) = shared;
}
else
HeKEY_hek(ret) = save_hek_flags(HeKEY(e), HeKLEN(e), HeHASH(e),
/* Need to swap the key we have for a key with the flags we
need. As keys are shared we can't just write to the
flag, so we share the new one, unshare the old one. */
- HEK *new_hek = HeKEY_hek(share_hek_flags(key, klen, hash,
- masked_flags));
+ HEK *new_hek = share_hek_flags(key, klen, hash,
+ masked_flags);
unshare_hek (HeKEY_hek(entry));
HeKEY_hek(entry) = new_hek;
}
/* share_hek_flags will do the free for us. This might be considered
bad API design. */
if (HvSHAREKEYS(hv))
- HeKEY_hek(entry) = HeKEY_hek(share_hek_flags(key, klen, hash, flags));
+ HeKEY_hek(entry) = share_hek_flags(key, klen, hash, flags);
else /* gotta do the real thing */
HeKEY_hek(entry) = save_hek_flags(key, klen, hash, flags);
HeVAL(entry) = val;
ent = new_HE();
HeVAL(ent) = newSVsv(HeVAL(oent));
HeKEY_hek(ent)
- = shared ? HeKEY_hek(share_hek_flags(key, len, hash, flags))
+ = shared ? share_hek_flags(key, len, hash, flags)
: save_hek_flags(key, len, hash, flags);
if (prev)
HeNEXT(prev) = ent;
bool is_utf8 = FALSE;
int k_flags = 0;
const char *save = str;
+ struct shared_he *he = 0;
if (hek) {
+ /* Find the shared he which is just before us in memory. */
+ he = (struct shared_he *)(((char *)hek)
+ - STRUCT_OFFSET(struct shared_he,
+ shared_he_hek));
+
+ /* Assert that the caller passed us a genuine (or at least consistent)
+ shared hek */
+ assert (he->shared_he_he.hent_hek == hek);
+
+ LOCK_STRTAB_MUTEX;
+ if (he->shared_he_he.hent_val - 1) {
+ --he->shared_he_he.hent_val;
+ UNLOCK_STRTAB_MUTEX;
+ return;
+ }
+ UNLOCK_STRTAB_MUTEX;
+
hash = HEK_HASH(hek);
} else if (len < 0) {
STRLEN tmplen = -len;
/* assert(xhv_array != 0) */
LOCK_STRTAB_MUTEX;
first = oentry = &(HvARRAY(PL_strtab))[hash & (I32) HvMAX(PL_strtab)];
- if (hek) {
+ if (he) {
+ const HE *const he_he = &(he->shared_he_he);
for (entry = *oentry; entry; oentry = &HeNEXT(entry), entry = *oentry) {
- if (HeKEY_hek(entry) != hek)
+ if (entry != he_he)
continue;
found = 1;
break;
/* There are now no entries in our slot. */
xhv->xhv_fill--; /* HvFILL(hv)-- */
}
- Safefree(HeKEY_hek(entry));
- del_HE(entry);
+ Safefree(entry);
xhv->xhv_keys--; /* HvKEYS(hv)-- */
}
}
flags |= HVhek_WASUTF8 | HVhek_FREEKEY;
}
- return HeKEY_hek(share_hek_flags (str, len, hash, flags));
+ return share_hek_flags (str, len, hash, flags);
}
-STATIC HE *
+STATIC HEK *
S_share_hek_flags(pTHX_ const char *str, I32 len, register U32 hash, int flags)
{
register XPVHV* xhv;
If this is NULL, then we're the first entry for this slot, which
means we need to increate fill. */
const HE *old_first = *oentry;
- entry = new_HE();
- HeKEY_hek(entry) = save_hek_flags(str, len, hash, flags_masked);
+ struct shared_he *new_entry;
+ HEK *hek;
+ char *k;
+
+ /* We don't actually store a HE from the arena and a regular HEK.
+ Instead we allocate one chunk of memory big enough for both,
+ and put the HEK straight after the HE. This way we can find the
+ HEK directly from the HE.
+ */
+
+ New(0, k, STRUCT_OFFSET(struct shared_he,
+ shared_he_hek.hek_key[0]) + len + 2, char);
+ new_entry = (struct shared_he *)k;
+ entry = &(new_entry->shared_he_he);
+ hek = &(new_entry->shared_he_hek);
+
+ Copy(str, HEK_KEY(hek), len, char);
+ HEK_KEY(hek)[len] = 0;
+ HEK_LEN(hek) = len;
+ HEK_HASH(hek) = hash;
+ HEK_FLAGS(hek) = (unsigned char)flags_masked;
+
+ /* Still "point" to the HEK, so that other code need not know what
+ we're up to. */
+ HeKEY_hek(entry) = hek;
HeVAL(entry) = Nullsv;
HeNEXT(entry) = *oentry;
*oentry = entry;
+
xhv->xhv_keys++; /* HvKEYS(hv)++ */
if (!old_first) { /* initial entry? */
xhv->xhv_fill++; /* HvFILL(hv)++ */
if (flags & HVhek_FREEKEY)
Safefree(str);
- return entry;
+ return HeKEY_hek(entry);
}
I32 *