[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
scratch/hash-table-perf afd2185bfdb 20/35: Store hash values as integers
From: |
Mattias Engdegård |
Subject: |
scratch/hash-table-perf afd2185bfdb 20/35: Store hash values as integers instead of Lisp_Object |
Date: |
Fri, 12 Jan 2024 10:53:25 -0500 (EST) |
branch: scratch/hash-table-perf
commit afd2185bfdb25b2624c8d3cbe9133d548d919549
Author: Mattias Engdegård <mattiase@acm.org>
Commit: Mattias Engdegård <mattiase@acm.org>
Store hash values as integers instead of Lisp_Object
This improves typing, saves pointless tagging and untagging, and
prepares for further changes. The new typedef hash_hash_t is an alias
for EMACS_UINT, and hash values are still limited to the fixnum range.
We now use hash_unused instead of Qnil to mark unused entries.
* src/lisp.h (hash_hash_t): New typedef for EMACS_UINT.
(hash_unused): New constant.
(struct hash_table_test): `hashfn` now returns
hash_hash_t. All callers and implementations changed.
(struct Lisp_Hash_Table): Retype hash vector to an array of
hash_hash_t. All code using it changed accordingly.
(HASH_HASH, hash_from_key):
* src/fns.c (set_hash_index_slot, hash_index_index)
(hash_lookup_with_hash, hash_lookup_get_hash, hash_put):
(hash_lookup, hash_put): Retype hash value arguments
and return values. All callers adapted.
---
src/category.c | 2 +-
src/charset.c | 2 +-
src/composite.c | 5 ++--
src/emacs-module.c | 3 ++-
src/fns.c | 76 ++++++++++++++++++++++++++++--------------------------
src/image.c | 3 ++-
src/json.c | 3 ++-
src/lisp.h | 29 ++++++++++++++-------
src/lread.c | 8 +++---
src/macfont.m | 5 ++--
src/pdumper.c | 2 +-
11 files changed, 78 insertions(+), 60 deletions(-)
diff --git a/src/category.c b/src/category.c
index fe07c11fdee..a052533788b 100644
--- a/src/category.c
+++ b/src/category.c
@@ -53,7 +53,7 @@ hash_get_category_set (Lisp_Object table, Lisp_Object
category_set)
(table, 1,
make_hash_table (hashtest_equal, DEFAULT_HASH_SIZE, Weak_None, false));
struct Lisp_Hash_Table *h = XHASH_TABLE (XCHAR_TABLE (table)->extras[1]);
- Lisp_Object hash;
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h, category_set, &hash);
if (i >= 0)
return HASH_KEY (h, i);
diff --git a/src/charset.c b/src/charset.c
index d5e42d038df..fb0e6e3933f 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -850,7 +850,6 @@ usage: (define-charset-internal ...) */)
/* Charset attr vector. */
Lisp_Object attrs;
Lisp_Object val;
- Lisp_Object hash_code;
struct Lisp_Hash_Table *hash_table = XHASH_TABLE (Vcharset_hash_table);
int i, j;
struct charset charset;
@@ -1108,6 +1107,7 @@ usage: (define-charset-internal ...) */)
CHECK_LIST (args[charset_arg_plist]);
ASET (attrs, charset_plist, args[charset_arg_plist]);
+ hash_hash_t hash_code;
charset.hash_index = hash_lookup (hash_table, args[charset_arg_name],
&hash_code);
if (charset.hash_index >= 0)
diff --git a/src/composite.c b/src/composite.c
index f9cf17770dc..20572d6fc4d 100644
--- a/src/composite.c
+++ b/src/composite.c
@@ -166,7 +166,7 @@ ptrdiff_t
get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos, ptrdiff_t nchars,
Lisp_Object prop, Lisp_Object string)
{
- Lisp_Object id, length, components, key, *key_contents, hash_code;
+ Lisp_Object id, length, components, key, *key_contents;
ptrdiff_t glyph_len;
struct Lisp_Hash_Table *hash_table = XHASH_TABLE (composition_hash_table);
ptrdiff_t hash_index;
@@ -240,6 +240,7 @@ get_composition_id (ptrdiff_t charpos, ptrdiff_t bytepos,
ptrdiff_t nchars,
else
goto invalid_composition;
+ hash_hash_t hash_code;
hash_index = hash_lookup (hash_table, key, &hash_code);
if (hash_index >= 0)
{
@@ -653,7 +654,7 @@ composition_gstring_put_cache (Lisp_Object gstring,
ptrdiff_t len)
{
struct Lisp_Hash_Table *h = XHASH_TABLE (gstring_hash_table);
Lisp_Object header = LGSTRING_HEADER (gstring);
- Lisp_Object hash = hash_from_key (h, header);
+ EMACS_UINT hash = hash_from_key (h, header);
if (len < 0)
{
ptrdiff_t glyph_len = LGSTRING_GLYPH_LEN (gstring);
diff --git a/src/emacs-module.c b/src/emacs-module.c
index c7d2a6974e8..5dacddff596 100644
--- a/src/emacs-module.c
+++ b/src/emacs-module.c
@@ -427,7 +427,8 @@ module_make_global_ref (emacs_env *env, emacs_value value)
{
MODULE_FUNCTION_BEGIN (NULL);
struct Lisp_Hash_Table *h = XHASH_TABLE (Vmodule_refs_hash);
- Lisp_Object new_obj = value_to_lisp (value), hashcode;
+ Lisp_Object new_obj = value_to_lisp (value);
+ hash_hash_t hashcode;
ptrdiff_t i = hash_lookup (h, new_obj, &hashcode);
/* Note: This approach requires the garbage collector to never move
diff --git a/src/fns.c b/src/fns.c
index 4b2d78fbb6a..2dfba205e6b 100644
--- a/src/fns.c
+++ b/src/fns.c
@@ -2759,7 +2759,7 @@ internal_equal (Lisp_Object o1, Lisp_Object o2, enum
equal_kind equal_kind,
case Lisp_Cons: case Lisp_Vectorlike:
{
struct Lisp_Hash_Table *h = XHASH_TABLE (ht);
- Lisp_Object hash;
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h, o1, &hash);
if (i >= 0)
{ /* `o1' was seen already. */
@@ -4279,7 +4279,7 @@ set_hash_next_slot (struct Lisp_Hash_Table *h, ptrdiff_t
idx, ptrdiff_t val)
h->next[idx] = val;
}
static void
-set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, Lisp_Object val)
+set_hash_hash_slot (struct Lisp_Hash_Table *h, ptrdiff_t idx, hash_hash_t val)
{
eassert (idx >= 0 && idx < h->table_size);
h->hash[idx] = val;
@@ -4450,41 +4450,42 @@ cmpfn_user_defined (Lisp_Object key1, Lisp_Object key2,
/* Ignore H and return a hash code for KEY which uses 'eq' to compare keys. */
-static Lisp_Object
+static hash_hash_t
hashfn_eq (Lisp_Object key, struct Lisp_Hash_Table *h)
{
if (symbols_with_pos_enabled && SYMBOL_WITH_POS_P (key))
key = SYMBOL_WITH_POS_SYM (key);
- return make_ufixnum (XHASH (key) ^ XTYPE (key));
+ return XHASH (key) ^ XTYPE (key);
}
/* Ignore H and return a hash code for KEY which uses 'equal' to compare keys.
The hash code is at most INTMASK. */
-static Lisp_Object
+static hash_hash_t
hashfn_equal (Lisp_Object key, struct Lisp_Hash_Table *h)
{
- return make_ufixnum (sxhash (key));
+ return sxhash (key);
}
/* Ignore H and return a hash code for KEY which uses 'eql' to compare keys.
The hash code is at most INTMASK. */
-static Lisp_Object
+static hash_hash_t
hashfn_eql (Lisp_Object key, struct Lisp_Hash_Table *h)
{
- return (FLOATP (key) || BIGNUMP (key) ? hashfn_equal : hashfn_eq) (key, h);
+ return (FLOATP (key) || BIGNUMP (key)
+ ? hashfn_equal (key, h) : hashfn_eq (key, h));
}
/* Given H, return a hash code for KEY which uses a user-defined
function to compare keys. */
-static Lisp_Object
+static hash_hash_t
hashfn_user_defined (Lisp_Object key, struct Lisp_Hash_Table *h)
{
Lisp_Object args[] = { h->test.user_hash_function, key };
Lisp_Object hash = hash_table_user_defined_call (ARRAYELTS (args), args, h);
- return FIXNUMP (hash) ? hash : make_ufixnum (sxhash (hash));
+ return FIXNUMP (hash) ? XUFIXNUM(hash) : sxhash (hash);
}
struct hash_table_test const
@@ -4567,7 +4568,8 @@ make_hash_table (struct hash_table_test test, EMACS_INT
size,
h->key_and_value[i] = HASH_UNUSED_ENTRY_KEY;
h->hash = hash_table_alloc_bytes (size * sizeof *h->hash);
- memclear (h->hash, size * sizeof *h->hash);
+ for (ptrdiff_t i = 0; i < size; i++)
+ h->hash[i] = hash_unused;
h->next = hash_table_alloc_bytes (size * sizeof *h->next);
for (ptrdiff_t i = 0; i < size - 1; i++)
@@ -4632,10 +4634,10 @@ copy_hash_table (struct Lisp_Hash_Table *h1)
/* Compute index into the index vector from a hash value. */
static inline ptrdiff_t
-hash_index_index (struct Lisp_Hash_Table *h, Lisp_Object hash_code)
+hash_index_index (struct Lisp_Hash_Table *h, hash_hash_t hash)
{
eassert (h->index_size > 0);
- return XUFIXNUM (hash_code) % h->index_size;
+ return hash % h->index_size;
}
/* Resize hash table H if it's too full. If H cannot be resized
@@ -4673,9 +4675,10 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
for (ptrdiff_t i = 2 * old_size; i < 2 * new_size; i++)
key_and_value[i] = HASH_UNUSED_ENTRY_KEY;
- Lisp_Object *hash = hash_table_alloc_bytes (new_size * sizeof *hash);
+ hash_hash_t *hash = hash_table_alloc_bytes (new_size * sizeof *hash);
memcpy (hash, h->hash, old_size * sizeof *hash);
- memclear (hash + old_size, (new_size - old_size) * word_size);
+ for (ptrdiff_t i = old_size; i < new_size; i++)
+ hash[i] = hash_unused;
ptrdiff_t old_index_size = h->index_size;
ptrdiff_t index_size = hash_index_size (new_size);
@@ -4704,9 +4707,9 @@ maybe_resize_hash_table (struct Lisp_Hash_Table *h)
/* Rehash. */
for (ptrdiff_t i = 0; i < old_size; i++)
- if (!NILP (HASH_HASH (h, i)))
+ if (HASH_HASH (h, i) != hash_unused)
{
- Lisp_Object hash_code = HASH_HASH (h, i);
+ hash_hash_t hash_code = HASH_HASH (h, i);
ptrdiff_t start_of_bucket = hash_index_index (h, hash_code);
set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket));
set_hash_index_slot (h, start_of_bucket, i);
@@ -4747,7 +4750,8 @@ hash_table_thaw (Lisp_Object hash_table)
h->next_free = -1;
h->hash = hash_table_alloc_bytes (size * sizeof *h->hash);
- memclear (h->hash, size * sizeof *h->hash);
+ for (ptrdiff_t i = 0; i < size; i++)
+ h->hash[i] = hash_unused;
h->next = hash_table_alloc_bytes (size * sizeof *h->next);
for (ptrdiff_t i = 0; i < size; i++)
@@ -4762,7 +4766,7 @@ hash_table_thaw (Lisp_Object hash_table)
for (ptrdiff_t i = 0; i < size; i++)
{
Lisp_Object key = HASH_KEY (h, i);
- Lisp_Object hash_code = hash_from_key (h, key);
+ hash_hash_t hash_code = hash_from_key (h, key);
ptrdiff_t start_of_bucket = hash_index_index (h, hash_code);
set_hash_hash_slot (h, i, hash_code);
set_hash_next_slot (h, i, HASH_INDEX (h, start_of_bucket));
@@ -4775,9 +4779,9 @@ hash_table_thaw (Lisp_Object hash_table)
matching KEY, or -1 if not found. */
ptrdiff_t
-hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object *hash)
+hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key, hash_hash_t *hash)
{
- Lisp_Object hash_code = hash_from_key (h, key);
+ hash_hash_t hash_code = hash_from_key (h, key);
if (hash)
*hash = hash_code;
@@ -4786,7 +4790,7 @@ hash_lookup (struct Lisp_Hash_Table *h, Lisp_Object key,
Lisp_Object *hash)
for (i = HASH_INDEX (h, start_of_bucket); 0 <= i; i = HASH_NEXT (h, i))
if (EQ (key, HASH_KEY (h, i))
|| (h->test.cmpfn
- && EQ (hash_code, HASH_HASH (h, i))
+ && hash_code == HASH_HASH (h, i)
&& !NILP (h->test.cmpfn (key, HASH_KEY (h, i), h))))
break;
@@ -4807,7 +4811,7 @@ check_mutable_hash_table (Lisp_Object obj, struct
Lisp_Hash_Table *h)
ptrdiff_t
hash_put (struct Lisp_Hash_Table *h, Lisp_Object key, Lisp_Object value,
- Lisp_Object hash)
+ hash_hash_t hash)
{
/* Increment count after resizing because resizing may fail. */
maybe_resize_hash_table (h);
@@ -4815,7 +4819,7 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key,
Lisp_Object value,
/* Store key/value in the key_and_value vector. */
ptrdiff_t i = h->next_free;
- eassert (NILP (HASH_HASH (h, i)));
+ eassert (HASH_HASH (h, i) == hash_unused);
eassert (hash_unused_entry_key_p (HASH_KEY (h, i)));
h->next_free = HASH_NEXT (h, i);
set_hash_key_slot (h, i, key);
@@ -4837,8 +4841,8 @@ hash_put (struct Lisp_Hash_Table *h, Lisp_Object key,
Lisp_Object value,
void
hash_remove_from_table (struct Lisp_Hash_Table *h, Lisp_Object key)
{
- Lisp_Object hash_code = hash_from_key (h, key);
- ptrdiff_t start_of_bucket = hash_index_index (h, hash_code);
+ hash_hash_t hashval = hash_from_key (h, key);
+ ptrdiff_t start_of_bucket = hash_index_index (h, hashval);
ptrdiff_t prev = -1;
for (ptrdiff_t i = HASH_INDEX (h, start_of_bucket);
@@ -4847,7 +4851,7 @@ hash_remove_from_table (struct Lisp_Hash_Table *h,
Lisp_Object key)
{
if (EQ (key, HASH_KEY (h, i))
|| (h->test.cmpfn
- && EQ (hash_code, HASH_HASH (h, i))
+ && hashval == HASH_HASH (h, i)
&& !NILP (h->test.cmpfn (key, HASH_KEY (h, i), h))))
{
/* Take entry out of collision chain. */
@@ -4860,7 +4864,7 @@ hash_remove_from_table (struct Lisp_Hash_Table *h,
Lisp_Object key)
the free list. */
set_hash_key_slot (h, i, HASH_UNUSED_ENTRY_KEY);
set_hash_value_slot (h, i, Qnil);
- set_hash_hash_slot (h, i, Qnil);
+ set_hash_hash_slot (h, i, hash_unused);
set_hash_next_slot (h, i, h->next_free);
h->next_free = i;
h->count--;
@@ -4881,9 +4885,9 @@ hash_clear (struct Lisp_Hash_Table *h)
if (h->count > 0)
{
ptrdiff_t size = HASH_TABLE_SIZE (h);
- memclear (h->hash, size * word_size);
for (ptrdiff_t i = 0; i < size; i++)
{
+ set_hash_hash_slot (h, i, hash_unused);
set_hash_next_slot (h, i, i < size - 1 ? i + 1 : -1);
set_hash_key_slot (h, i, HASH_UNUSED_ENTRY_KEY);
set_hash_value_slot (h, i, Qnil);
@@ -4966,7 +4970,7 @@ sweep_weak_table (struct Lisp_Hash_Table *h, bool
remove_entries_p)
/* Clear key, value, and hash. */
set_hash_key_slot (h, i, HASH_UNUSED_ENTRY_KEY);
set_hash_value_slot (h, i, Qnil);
- set_hash_hash_slot (h, i, Qnil);
+ set_hash_hash_slot (h, i, hash_unused);
eassert (h->count != 0);
h->count--;
@@ -5252,7 +5256,7 @@ If (eq A B), then (= (sxhash-eq A) (sxhash-eq B)).
Hash codes are not guaranteed to be preserved across Emacs sessions. */)
(Lisp_Object obj)
{
- return hashfn_eq (obj, NULL);
+ return make_ufixnum (hashfn_eq (obj, NULL));
}
DEFUN ("sxhash-eql", Fsxhash_eql, Ssxhash_eql, 1, 1, 0,
@@ -5263,7 +5267,7 @@ isn't necessarily true.
Hash codes are not guaranteed to be preserved across Emacs sessions. */)
(Lisp_Object obj)
{
- return hashfn_eql (obj, NULL);
+ return make_ufixnum (hashfn_eql (obj, NULL));
}
DEFUN ("sxhash-equal", Fsxhash_equal, Ssxhash_equal, 1, 1, 0,
@@ -5274,7 +5278,7 @@ opposite isn't necessarily true.
Hash codes are not guaranteed to be preserved across Emacs sessions. */)
(Lisp_Object obj)
{
- return hashfn_equal (obj, NULL);
+ return make_ufixnum (hashfn_equal (obj, NULL));
}
DEFUN ("sxhash-equal-including-properties", Fsxhash_equal_including_properties,
@@ -5298,7 +5302,7 @@ Hash codes are not guaranteed to be preserved across
Emacs sessions. */)
sxhash (CDR (collector)))));
}
- return hashfn_equal (obj, NULL);
+ return make_ufixnum (hashfn_equal (obj, NULL));
}
DEFUN ("make-hash-table", Fmake_hash_table, Smake_hash_table, 0, MANY, 0,
@@ -5532,7 +5536,7 @@ VALUE. In any case, return VALUE. */)
struct Lisp_Hash_Table *h = check_hash_table (table);
check_mutable_hash_table (table, h);
- Lisp_Object hash;
+ EMACS_UINT hash;
ptrdiff_t i = hash_lookup (h, key, &hash);
if (i >= 0)
set_hash_value_slot (h, i, value);
@@ -5633,7 +5637,7 @@ Internal use only. */)
{
Lisp_Object bucket = Qnil;
for (ptrdiff_t j = HASH_INDEX (h, i); j != -1; j = HASH_NEXT (h, j))
- bucket = Fcons (Fcons (HASH_KEY (h, j), HASH_HASH (h, j)),
+ bucket = Fcons (Fcons (HASH_KEY (h, j), make_int (HASH_HASH (h, j))),
bucket);
if (!NILP (bucket))
ret = Fcons (Fnreverse (bucket), ret);
diff --git a/src/image.c b/src/image.c
index ad1b80fa97e..0fdda920cf3 100644
--- a/src/image.c
+++ b/src/image.c
@@ -6079,8 +6079,9 @@ xpm_put_color_table_h (Lisp_Object color_table,
Lisp_Object color)
{
struct Lisp_Hash_Table *table = XHASH_TABLE (color_table);
- Lisp_Object chars = make_unibyte_string (chars_start, chars_len), hash_code;
+ Lisp_Object chars = make_unibyte_string (chars_start, chars_len);
+ hash_hash_t hash_code;
hash_lookup (table, chars, &hash_code);
hash_put (table, chars, color, hash_code);
}
diff --git a/src/json.c b/src/json.c
index de9bac41e52..79b3448b0d9 100644
--- a/src/json.c
+++ b/src/json.c
@@ -879,7 +879,8 @@ json_to_lisp (json_t *json, const struct json_configuration
*conf)
json_t *value;
json_object_foreach (json, key_str, value)
{
- Lisp_Object key = build_string_from_utf8 (key_str), hash;
+ Lisp_Object key = build_string_from_utf8 (key_str);
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h, key, &hash);
/* Keys in JSON objects are unique, so the key can't
be present yet. */
diff --git a/src/lisp.h b/src/lisp.h
index e9498e6751f..08145467cfb 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -2385,6 +2385,10 @@ INLINE int
struct Lisp_Hash_Table;
+/* The type of a hash value stored in the table.
+ It's unsigned and a subtype of EMACS_UINT. */
+typedef EMACS_UINT hash_hash_t;
+
typedef enum {
Test_eql,
Test_eq,
@@ -2406,7 +2410,7 @@ struct hash_table_test
Lisp_Object (*cmpfn) (Lisp_Object, Lisp_Object, struct Lisp_Hash_Table *);
/* C function to compute hash code. */
- Lisp_Object (*hashfn) (Lisp_Object, struct Lisp_Hash_Table *);
+ hash_hash_t (*hashfn) (Lisp_Object, struct Lisp_Hash_Table *);
};
typedef enum {
@@ -2421,6 +2425,11 @@ typedef enum {
both key and value remain. */
} hash_table_weakness_t;
+/* An value that marks an unused hash entry.
+ Any hash_hash_t value that is not a valid fixnum will do here. */
+enum { hash_unused = (hash_hash_t)MOST_POSITIVE_FIXNUM + 1 };
+verify (FIXNUM_OVERFLOW_P (hash_unused));
+
struct Lisp_Hash_Table
{
union vectorlike_header header;
@@ -2452,16 +2461,16 @@ struct Lisp_Hash_Table
/* Bucket vector. An entry of -1 indicates no item is present,
and a nonnegative entry is the index of the first item in
- a collision chain. This vector's size can be larger than the
- hash table size to reduce collisions. */
+ a collision chain.
+ This vector is index_size entries long. */
ptrdiff_t *index;
ptrdiff_t index_size; /* Size of the index vector. */
ptrdiff_t table_size; /* Size of the next and hash vectors. */
- /* Vector of hash codes. Each entry is either a fixnum, or nil if unused.
+ /* Vector of hash codes. The value hash_unused marks an unused table entry.
This vector is table_size entries long. */
- Lisp_Object *hash;
+ hash_hash_t *hash;
/* Vector used to chain entries. If entry I is free, next[I] is the
entry number of the next free item. If entry I is non-free,
@@ -2550,7 +2559,7 @@ HASH_VALUE (const struct Lisp_Hash_Table *h, ptrdiff_t
idx)
}
/* Value is the hash code computed for entry IDX in hash table H. */
-INLINE Lisp_Object
+INLINE hash_hash_t
HASH_HASH (const struct Lisp_Hash_Table *h, ptrdiff_t idx)
{
eassert (idx >= 0 && idx < h->table_size);
@@ -2564,8 +2573,8 @@ HASH_TABLE_SIZE (const struct Lisp_Hash_Table *h)
return h->table_size;
}
-/* Compute hash value for KEY in hash table H. */
-INLINE Lisp_Object
+/* Hash value for KEY in hash table H. */
+INLINE hash_hash_t
hash_from_key (struct Lisp_Hash_Table *h, Lisp_Object key)
{
return h->test.hashfn (key, h);
@@ -4018,9 +4027,9 @@ EMACS_UINT sxhash (Lisp_Object);
Lisp_Object make_hash_table (struct hash_table_test, EMACS_INT,
hash_table_weakness_t, bool);
Lisp_Object hash_table_weakness_symbol (hash_table_weakness_t weak);
-ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object *);
+ptrdiff_t hash_lookup (struct Lisp_Hash_Table *, Lisp_Object, hash_hash_t *);
ptrdiff_t hash_put (struct Lisp_Hash_Table *, Lisp_Object, Lisp_Object,
- Lisp_Object);
+ hash_hash_t);
void hash_remove_from_table (struct Lisp_Hash_Table *, Lisp_Object);
extern struct hash_table_test const hashtest_eq, hashtest_eql, hashtest_equal;
extern void validate_subarray (Lisp_Object, Lisp_Object, Lisp_Object,
diff --git a/src/lread.c b/src/lread.c
index bdd8239afe0..0de052344ba 100644
--- a/src/lread.c
+++ b/src/lread.c
@@ -4255,7 +4255,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
struct Lisp_Hash_Table *h
= XHASH_TABLE (read_objects_map);
Lisp_Object number = make_fixnum (n);
- Lisp_Object hash;
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h, number, &hash);
if (i >= 0)
/* Not normal, but input could be malformed. */
@@ -4571,7 +4571,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
struct Lisp_Hash_Table *h2
= XHASH_TABLE (read_objects_completed);
- Lisp_Object hash;
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h2, placeholder, &hash);
eassert (i < 0);
hash_put (h2, placeholder, Qnil, hash);
@@ -4586,7 +4586,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
{
struct Lisp_Hash_Table *h2
= XHASH_TABLE (read_objects_completed);
- Lisp_Object hash;
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h2, obj, &hash);
eassert (i < 0);
hash_put (h2, obj, Qnil, hash);
@@ -4598,7 +4598,7 @@ read0 (Lisp_Object readcharfun, bool locate_syms)
/* ...and #n# will use the real value from now on. */
struct Lisp_Hash_Table *h = XHASH_TABLE (read_objects_map);
- Lisp_Object hash;
+ hash_hash_t hash;
ptrdiff_t i = hash_lookup (h, e->u.numbered.number, &hash);
eassert (i >= 0);
set_hash_value_slot (h, i, obj);
diff --git a/src/macfont.m b/src/macfont.m
index 9f9f6f4efaf..d90bf7e655d 100644
--- a/src/macfont.m
+++ b/src/macfont.m
@@ -980,7 +980,7 @@ macfont_invalidate_family_cache (void)
ptrdiff_t i, size = HASH_TABLE_SIZE (h);
for (i = 0; i < size; ++i)
- if (!NILP (HASH_HASH (h, i)))
+ if (HASH_HASH (h, i) != hash_unused)
{
Lisp_Object value = HASH_VALUE (h, i);
@@ -1017,12 +1017,13 @@ macfont_set_family_cache (Lisp_Object symbol,
CFStringRef string)
{
struct Lisp_Hash_Table *h;
ptrdiff_t i;
- Lisp_Object hash, value;
+ Lisp_Object value;
if (!HASH_TABLE_P (macfont_family_cache))
macfont_family_cache = CALLN (Fmake_hash_table, QCtest, Qeq);
h = XHASH_TABLE (macfont_family_cache);
+ hash_hash_t hash;
i = hash_lookup (h, symbol, &hash);
value = string ? make_mint_ptr ((void *) CFRetain (string)) : Qnil;
if (i >= 0)
diff --git a/src/pdumper.c b/src/pdumper.c
index 5d02fbd061d..bc31dd8fa6d 100644
--- a/src/pdumper.c
+++ b/src/pdumper.c
@@ -2661,7 +2661,7 @@ hash_table_contents (struct Lisp_Hash_Table *h)
relies on it by expecting hash table indices to stay constant
across the dump. */
for (ptrdiff_t i = 0; i < old_size; i++)
- if (!NILP (HASH_HASH (h, i)))
+ if (HASH_HASH (h, i) != hash_unused)
{
key_and_value[n++] = HASH_KEY (h, i);
key_and_value[n++] = HASH_VALUE (h, i);
- scratch/hash-table-perf 8ec0e030b66 35/35: Combine hash and next vector into a single array, (continued)
- scratch/hash-table-perf 8ec0e030b66 35/35: Combine hash and next vector into a single array, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf b9a0b88aea8 05/35: ; * src/fns.c (collect_interval): Move misplaced function., Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf ed4ce0af9a9 06/35: Refactor: extract hash and index computations to functions, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf e55fcdafa07 09/35: Abstract predicate and constant for unused hash keys, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 594152bf667 01/35: Add internal hash-table debug functions, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 422c91a822a 02/35: ; * src/pdumper.c (dump_hash_table): Remove unused argument., Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf f2d6e2713c0 07/35: Refactor hash table vector reallocation, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf dd4ee2c634b 15/35: Represent hash table weakness as an enum internally, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 615d3e4cdc6 17/35: Leaner hash table dumping and thawing, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf d003b84c484 19/35: Use non-Lisp allocation for internal hash-table vectors, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf afd2185bfdb 20/35: Store hash values as integers instead of Lisp_Object,
Mattias Engdegård <=
- scratch/hash-table-perf c98ba3d4fa6 21/35: Inlined and specialised hash table look-up, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 414470d1e24 23/35: Share hash table test structs, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 589318470c1 24/35: ; Reorder structs (hash and test), Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf bf1f1c5a9a4 25/35: Faster hash table growth, starting smaller, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 8811c5d81e7 27/35: Don't dump Qunbound, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf ef0323e9029 30/35: Adapt hash functions to produce a hash_hash_t eventually, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf c805d2173f8 33/35: Use a static index vector for zero-sized tables, Mattias Engdegård, 2024/01/12
- scratch/hash-table-perf 8884720dce8 34/35: Change default hash table size to 0, Mattias Engdegård, 2024/01/12