From 901935fbcec42cbf79594efd9cc2877810395715 Mon Sep 17 00:00:00 2001 From: "Emil J. Tywoniak" Date: Mon, 13 Jan 2025 20:21:05 +0100 Subject: [PATCH 1/3] hashlib: merge hash_ops with hash_top_ops for plugin compat --- kernel/hashlib.h | 58 ++++++++++++++++++++++++++++-------------------- kernel/rtlil.h | 14 ++++++++---- 2 files changed, 44 insertions(+), 28 deletions(-) diff --git a/kernel/hashlib.h b/kernel/hashlib.h index 4acfa7f2d..d166076d6 100644 --- a/kernel/hashlib.h +++ b/kernel/hashlib.h @@ -61,19 +61,9 @@ namespace legacy { } }; -/** - * Hash a type with an accumulator in a record or array context - */ template struct hash_ops; -/** - * Hash a single instance in isolation. - * Can have explicit specialization, but the default redirects to hash_ops - */ -template -struct hash_top_ops; - inline unsigned int mkhash_xorshift(unsigned int a) { if (sizeof(a) == 4) { a ^= a << 13; @@ -147,15 +137,14 @@ private: using Hasher = HasherDJB32; -template -struct hash_top_ops { - static inline bool cmp(const T &a, const T &b) { - return hash_ops::cmp(a, b); - } - static inline Hasher hash(const T &a) { - return hash_ops::hash_into(a, Hasher()); - } -}; +// Boilerplate compressor for trivially implementing +// top-level hash method with hash_into +#define HASH_TOP_LOOP_FST [[nodiscard]] static inline Hasher hash +#define HASH_TOP_LOOP_SND { \ + Hasher h; \ + h.eat(a); \ + return h; \ +} template struct hash_ops { @@ -183,6 +172,7 @@ struct hash_ops { return a.hash_into(h); } } + HASH_TOP_LOOP_FST (const T &a) HASH_TOP_LOOP_SND }; template struct hash_ops> { @@ -194,6 +184,7 @@ template struct hash_ops> { h = hash_ops::hash_into(a.second, h); return h; } + HASH_TOP_LOOP_FST (std::pair a) HASH_TOP_LOOP_SND }; template struct hash_ops> { @@ -211,6 +202,7 @@ template struct hash_ops> { h = element_ops_t::hash_into(std::get(a), h); return h; } + HASH_TOP_LOOP_FST (std::tuple a) HASH_TOP_LOOP_SND }; template struct hash_ops> { @@ -223,6 +215,7 @@ template struct hash_ops> { h.eat(k); return h; } + HASH_TOP_LOOP_FST (std::vector a) HASH_TOP_LOOP_SND }; template struct hash_ops> { @@ -234,6 +227,7 @@ template struct hash_ops> { h = hash_ops::hash_into(k, h); return h; } + HASH_TOP_LOOP_FST (std::array a) HASH_TOP_LOOP_SND }; struct hash_cstr_ops { @@ -245,6 +239,11 @@ struct hash_cstr_ops { h.hash32(*(a++)); return h; } + [[nodiscard]] static inline Hasher hash(const char *a) { + Hasher h; + h = hash_cstr_ops::hash_into(a, h); + return h; + } }; template <> struct hash_ops : hash_cstr_ops {}; @@ -256,6 +255,11 @@ struct hash_ptr_ops { [[nodiscard]] static inline Hasher hash_into(const void *a, Hasher h) { return hash_ops::hash_into((uintptr_t)a, h); } + [[nodiscard]] static inline Hasher hash(const void *a) { + Hasher h; + h = hash_ptr_ops::hash_into(a, h); + return h; + } }; struct hash_obj_ops { @@ -270,6 +274,12 @@ struct hash_obj_ops { h.eat(0); return h; } + template + [[nodiscard]] static inline Hasher hash(const T *a) { + Hasher h; + h = hash_obj_ops::hash_into(a, h); + return h; + } }; /** * If you find yourself using this function, think hard @@ -280,7 +290,7 @@ struct hash_obj_ops { template [[nodiscard]] Hasher::hash_t run_hash(const T& obj) { - return hash_top_ops::hash(obj).yield(); + return hash_ops::hash(obj).yield(); } /** Refer to docs/source/yosys_internals/hashing.rst */ @@ -352,10 +362,10 @@ inline unsigned int hashtable_size(unsigned int min_size) throw std::length_error("hash table exceeded maximum size."); } -template> class dict; -template> class idict; -template> class pool; -template> class mfp; +template> class dict; +template> class idict; +template> class pool; +template> class mfp; template class dict { diff --git a/kernel/rtlil.h b/kernel/rtlil.h index 3d8187e78..f9cacd151 100644 --- a/kernel/rtlil.h +++ b/kernel/rtlil.h @@ -398,13 +398,16 @@ struct RTLIL::IdString namespace hashlib { template <> - struct hash_top_ops { + struct hash_ops { static inline bool cmp(const RTLIL::IdString &a, const RTLIL::IdString &b) { return a == b; } - static inline Hasher hash(const RTLIL::IdString id) { + [[nodiscard]] static inline Hasher hash(const RTLIL::IdString id) { return id.hash_top(); } + [[nodiscard]] static inline Hasher hash_into(const RTLIL::IdString id, Hasher h) { + return id.hash_into(h); + } }; }; @@ -920,13 +923,16 @@ struct RTLIL::SigBit namespace hashlib { template <> - struct hash_top_ops { + struct hash_ops { static inline bool cmp(const RTLIL::SigBit &a, const RTLIL::SigBit &b) { return a == b; } - static inline Hasher hash(const RTLIL::SigBit sb) { + [[nodiscard]] static inline Hasher hash(const RTLIL::SigBit sb) { return sb.hash_top(); } + [[nodiscard]] static inline Hasher hash_into(const RTLIL::SigBit sb, Hasher h) { + return sb.hash_into(h); + } }; }; From aa01ef3312a709a90a797beca6eb4002abf7b8df Mon Sep 17 00:00:00 2001 From: "Emil J. Tywoniak" Date: Mon, 20 Jan 2025 16:15:48 +0100 Subject: [PATCH 2/3] hashlib: simplify loopback. NFC --- kernel/hashlib.h | 20 ++++---------------- 1 file changed, 4 insertions(+), 16 deletions(-) diff --git a/kernel/hashlib.h b/kernel/hashlib.h index d166076d6..6e3eb32a4 100644 --- a/kernel/hashlib.h +++ b/kernel/hashlib.h @@ -142,7 +142,7 @@ using Hasher = HasherDJB32; #define HASH_TOP_LOOP_FST [[nodiscard]] static inline Hasher hash #define HASH_TOP_LOOP_SND { \ Hasher h; \ - h.eat(a); \ + h = hash_into(a, h); \ return h; \ } @@ -239,11 +239,7 @@ struct hash_cstr_ops { h.hash32(*(a++)); return h; } - [[nodiscard]] static inline Hasher hash(const char *a) { - Hasher h; - h = hash_cstr_ops::hash_into(a, h); - return h; - } + HASH_TOP_LOOP_FST (const char *a) HASH_TOP_LOOP_SND }; template <> struct hash_ops : hash_cstr_ops {}; @@ -255,11 +251,7 @@ struct hash_ptr_ops { [[nodiscard]] static inline Hasher hash_into(const void *a, Hasher h) { return hash_ops::hash_into((uintptr_t)a, h); } - [[nodiscard]] static inline Hasher hash(const void *a) { - Hasher h; - h = hash_ptr_ops::hash_into(a, h); - return h; - } + HASH_TOP_LOOP_FST (const void *a) HASH_TOP_LOOP_SND }; struct hash_obj_ops { @@ -275,11 +267,7 @@ struct hash_obj_ops { return h; } template - [[nodiscard]] static inline Hasher hash(const T *a) { - Hasher h; - h = hash_obj_ops::hash_into(a, h); - return h; - } + HASH_TOP_LOOP_FST (const T *a) HASH_TOP_LOOP_SND }; /** * If you find yourself using this function, think hard From a2c26a00f2b55307bea27322c68dc7321c7ebc82 Mon Sep 17 00:00:00 2001 From: "Emil J. Tywoniak" Date: Mon, 20 Jan 2025 16:25:52 +0100 Subject: [PATCH 3/3] hashlib: document merged hash_top_ops with hash_ops --- docs/source/yosys_internals/hashing.rst | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/docs/source/yosys_internals/hashing.rst b/docs/source/yosys_internals/hashing.rst index 338ee5fd6..c6e22c0cf 100644 --- a/docs/source/yosys_internals/hashing.rst +++ b/docs/source/yosys_internals/hashing.rst @@ -97,8 +97,8 @@ Making a type hashable Let's first take a look at the external interface on a simplified level. Generally, to get the hash for ``T obj``, you would call the utility function -``run_hash(const T& obj)``, corresponding to ``hash_top_ops::hash(obj)``, -the default implementation of which is ``hash_ops::hash_into(Hasher(), obj)``. +``run_hash(const T& obj)``, corresponding to ``hash_ops::hash(obj)``, +the default implementation of which uses ``hash_ops::hash_into(Hasher(), obj)``. ``Hasher`` is the class actually implementing the hash function, hiding its initialized internal state, and passing it out on ``hash_t yield()`` with perhaps some finalization steps. @@ -121,8 +121,14 @@ size containers like ``std::vector`` the size of the container is hashed first. That is also how implementing hashing for a custom record data type should be - unless there is strong reason to do otherwise, call ``h.eat(m)`` on the ``Hasher h`` you have received for each member in sequence and ``return -h;``. If you do have a strong reason to do so, look at how -``hash_top_ops`` is implemented in ``kernel/rtlil.h``. +h;``. + +The ``hash_ops::hash(obj)`` method is not indended to be called when +context of implementing the hashing for a record or other compound type. +When writing it, you should connect it to ``hash_ops::hash_into(Hasher h)`` +as shown below. If you have a strong reason to do so, and you have +to create a special implementation for top-level hashing, look at how +``hash_ops::hash(...)`` is implemented in ``kernel/rtlil.h``. Porting plugins from the legacy interface ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -148,6 +154,11 @@ based on the existance and value of `YS_HASHING_VERSION`. h.eat(b); return h; } + Hasher T::hash() const { + Hasher h; + h.eat(*this); + return h; + } #else #error "Unsupported hashing interface" #endif