mesa/st: enable carry/borrow lowering pass

[mesa.git] / src / mesa / main / hash.c

diff --git a/src/mesa/main/hash.c b/src/mesa/main/hash.c
index 06c1be4a639cee17a3de6024ca794b7f54a50a09..23018e9da319224fec22d281c33c45ece8d62c7d 100644 (file)
--- a/src/mesa/main/hash.c
+++ b/src/mesa/main/hash.c
@@ -36,7 +36,6 @@
 
 #include "glheader.h"
 #include "imports.h"
-#include "glapi/glthread.h"
 #include "hash.h"
 #include "hash_table.h"
 
@@ -195,15 +194,55 @@ _mesa_HashLookup(struct _mesa_HashTable *table, GLuint key)
 
 
 /**
- * Insert a key/pointer pair into the hash table.  
- * If an entry with this key already exists we'll replace the existing entry.
- * 
+ * Lookup an entry in the hash table without locking the mutex.
+ *
+ * The hash table mutex must be locked manually by calling
+ * _mesa_HashLockMutex() before calling this function.
+ *
+ * \param table the hash table.
+ * \param key the key.
+ *
+ * \return pointer to user's data or NULL if key not in table
+ */
+void *
+_mesa_HashLookupLocked(struct _mesa_HashTable *table, GLuint key)
+{
+   return _mesa_HashLookup_unlocked(table, key);
+}
+
+
+/**
+ * Lock the hash table mutex.
+ *
+ * This function should be used when multiple objects need
+ * to be looked up in the hash table, to avoid having to lock
+ * and unlock the mutex each time.
+ *
  * \param table the hash table.
- * \param key the key (not zero).
- * \param data pointer to user data.
  */
 void
-_mesa_HashInsert(struct _mesa_HashTable *table, GLuint key, void *data)
+_mesa_HashLockMutex(struct _mesa_HashTable *table)
+{
+   assert(table);
+   mtx_lock(&table->Mutex);
+}
+
+
+/**
+ * Unlock the hash table mutex.
+ *
+ * \param table the hash table.
+ */
+void
+_mesa_HashUnlockMutex(struct _mesa_HashTable *table)
+{
+   assert(table);
+   mtx_unlock(&table->Mutex);
+}
+
+
+static inline void
+_mesa_HashInsert_unlocked(struct _mesa_HashTable *table, GLuint key, void *data)
 {
    uint32_t hash = uint_hash(key);
    struct hash_entry *entry;
@@ -211,8 +250,6 @@ _mesa_HashInsert(struct _mesa_HashTable *table, GLuint key, void *data)
    assert(table);
    assert(key);
 
-   mtx_lock(&table->Mutex);
-
    if (key > table->MaxKey)
       table->MaxKey = key;
 
@@ -226,11 +263,44 @@ _mesa_HashInsert(struct _mesa_HashTable *table, GLuint key, void *data)
          _mesa_hash_table_insert(table->ht, hash, uint_key(key), data);
       }
    }
+}
 
-   mtx_unlock(&table->Mutex);
+
+/**
+ * Insert a key/pointer pair into the hash table without locking the mutex.
+ * If an entry with this key already exists we'll replace the existing entry.
+ *
+ * The hash table mutex must be locked manually by calling
+ * _mesa_HashLockMutex() before calling this function.
+ *
+ * \param table the hash table.
+ * \param key the key (not zero).
+ * \param data pointer to user data.
+ */
+void
+_mesa_HashInsertLocked(struct _mesa_HashTable *table, GLuint key, void *data)
+{
+   _mesa_HashInsert_unlocked(table, key, data);
 }
 
 
+/**
+ * Insert a key/pointer pair into the hash table.
+ * If an entry with this key already exists we'll replace the existing entry.
+ *
+ * \param table the hash table.
+ * \param key the key (not zero).
+ * \param data pointer to user data.
+ */
+void
+_mesa_HashInsert(struct _mesa_HashTable *table, GLuint key, void *data)
+{
+   assert(table);
+   mtx_lock(&table->Mutex);
+   _mesa_HashInsert_unlocked(table, key, data);
+   mtx_unlock(&table->Mutex);
+}
+
 
 /**
  * Remove an entry from the hash table.