X-Git-Url: https://git.libre-soc.org/?a=blobdiff_plain;f=src%2Futil%2Fhash_table.h;h=b1eb9d4e217d743d850e0eb3c6fb5f2f0f23f426;hb=444138d6d9f7c0a07ff043bae623efa5ae26b3c1;hp=d3e0758b26517c4225ea302e3d892e4a42c6d709;hpb=a8b1715b8ab974518f9713b82955f049a2c1c7ec;p=mesa.git

diff --git a/src/util/hash_table.h b/src/util/hash_table.h
index d3e0758b265..b1eb9d4e217 100644
--- a/src/util/hash_table.h
+++ b/src/util/hash_table.h
@@ -32,6 +32,7 @@
 #include <inttypes.h>
 #include <stdbool.h>
 #include "c99_compat.h"
+#include "fnv1a.h"
 #include "macros.h"
 
 #ifdef __cplusplus
@@ -51,6 +52,8 @@ struct hash_table {
    const void *deleted_key;
    uint32_t size;
    uint32_t rehash;
+   uint64_t size_magic;
+   uint64_t rehash_magic;
    uint32_t max_entries;
    uint32_t size_index;
    uint32_t entries;
@@ -62,6 +65,16 @@ _mesa_hash_table_create(void *mem_ctx,
                         uint32_t (*key_hash_function)(const void *key),
                         bool (*key_equals_function)(const void *a,
                                                     const void *b));
+
+bool
+_mesa_hash_table_init(struct hash_table *ht,
+                      void *mem_ctx,
+                      uint32_t (*key_hash_function)(const void *key),
+                      bool (*key_equals_function)(const void *a,
+                                                  const void *b));
+
+struct hash_table *
+_mesa_hash_table_clone(struct hash_table *src, void *dst_mem_ctx);
 void _mesa_hash_table_destroy(struct hash_table *ht,
                               void (*delete_function)(struct hash_entry *entry));
 void _mesa_hash_table_clear(struct hash_table *ht,
@@ -86,6 +99,8 @@ _mesa_hash_table_search_pre_hashed(struct hash_table *ht, uint32_t hash,
                                   const void *key);
 void _mesa_hash_table_remove(struct hash_table *ht,
                              struct hash_entry *entry);
+void _mesa_hash_table_remove_key(struct hash_table *ht,
+                                 const void *key);
 
 struct hash_entry *_mesa_hash_table_next_entry(struct hash_table *ht,
                                                struct hash_entry *entry);
@@ -94,50 +109,30 @@ _mesa_hash_table_random_entry(struct hash_table *ht,
                               bool (*predicate)(struct hash_entry *entry));
 
 uint32_t _mesa_hash_data(const void *data, size_t size);
+
+uint32_t _mesa_hash_int(const void *key);
+uint32_t _mesa_hash_uint(const void *key);
+uint32_t _mesa_hash_u32(const void *key);
 uint32_t _mesa_hash_string(const void *key);
+uint32_t _mesa_hash_pointer(const void *pointer);
+
+bool _mesa_key_int_equal(const void *a, const void *b);
+bool _mesa_key_uint_equal(const void *a, const void *b);
+bool _mesa_key_u32_equal(const void *a, const void *b);
 bool _mesa_key_string_equal(const void *a, const void *b);
 bool _mesa_key_pointer_equal(const void *a, const void *b);
 
-static inline uint32_t _mesa_key_hash_string(const void *key)
-{
-   return _mesa_hash_string((const char *)key);
-}
-
-static inline uint32_t _mesa_hash_pointer(const void *pointer)
-{
-   uintptr_t num = (uintptr_t) pointer;
-   return (uint32_t) ((num >> 2) ^ (num >> 6) ^ (num >> 10) ^ (num >> 14));
-}
-
-enum {
-   _mesa_fnv32_1a_offset_bias = 2166136261u,
-};
-
-static inline uint32_t
-_mesa_fnv32_1a_accumulate_block(uint32_t hash, const void *data, size_t size)
-{
-   const uint8_t *bytes = (const uint8_t *)data;
-
-   while (size-- != 0) {
-      hash ^= *bytes;
-      hash = hash * 0x01000193;
-      bytes++;
-   }
-
-   return hash;
-}
-
-#define _mesa_fnv32_1a_accumulate(hash, expr) \
-   _mesa_fnv32_1a_accumulate_block(hash, &(expr), sizeof(expr))
+struct hash_table *
+_mesa_pointer_hash_table_create(void *mem_ctx);
 
 /**
  * This foreach function is safe against deletion (which just replaces
  * an entry's data with the deleted marker), but not against insertion
  * (which may rehash the table, making entry a dangling pointer).
  */
-#define hash_table_foreach(ht, entry)                   \
-   for (entry = _mesa_hash_table_next_entry(ht, NULL);  \
-        entry != NULL;                                  \
+#define hash_table_foreach(ht, entry)                                      \
+   for (struct hash_entry *entry = _mesa_hash_table_next_entry(ht, NULL);  \
+        entry != NULL;                                                     \
         entry = _mesa_hash_table_next_entry(ht, entry))
 
 static inline void
@@ -147,8 +142,6 @@ hash_table_call_foreach(struct hash_table *ht,
                                          void *closure),
                         void *closure)
 {
-   struct hash_entry *entry;
-
    hash_table_foreach(ht, entry)
       callback(entry->key, entry->data, closure);
 }
@@ -158,6 +151,7 @@ hash_table_call_foreach(struct hash_table *ht,
  */
 struct hash_table_u64 {
    struct hash_table *table;
+   void *freed_key_data;
    void *deleted_key_data;
 };
 
@@ -178,6 +172,10 @@ _mesa_hash_table_u64_search(struct hash_table_u64 *ht, uint64_t key);
 void
 _mesa_hash_table_u64_remove(struct hash_table_u64 *ht, uint64_t key);
 
+void
+_mesa_hash_table_u64_clear(struct hash_table_u64 *ht,
+                           void (*delete_function)(struct hash_entry *entry));
+
 #ifdef __cplusplus
 } /* extern C */
 #endif