Overhaul of texture image handling.

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

diff --git a/src/mesa/main/hash.c b/src/mesa/main/hash.c
index 20f81962bf070908857ee7f9789493e44fbfa7ad..17bcd1c5f3e62eb605a66b3f13659d25090d319e 100644 (file)
--- a/src/mesa/main/hash.c
+++ b/src/mesa/main/hash.c
@@ -1,10 +1,10 @@
-/* $Id: hash.c,v 1.5 2000/01/04 08:14:36 brianp Exp $ */
+/* $Id: hash.c,v 1.9 2000/03/21 22:20:42 brianp Exp $ */
 
 /*
  * Mesa 3-D graphics library
  * Version:  3.3
  * 
- * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * Copyright (C) 1999-2000  Brian Paul   All Rights Reserved.
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the "Software"),
@@ -29,6 +29,7 @@
 #include "all.h"
 #else
 #include "glheader.h"
+#include "glthread.h"
 #include "hash.h"
 #include "mem.h"
 #endif
@@ -50,9 +51,10 @@ struct HashEntry {
    struct HashEntry *Next;
 };
 
-struct HashTable {
+struct _mesa_HashTable {
    struct HashEntry *Table[TABLE_SIZE];
    GLuint MaxKey;
+   _glthread_Mutex Mutex;
 };
 
 
@@ -60,9 +62,9 @@ struct HashTable {
 /*
  * Return pointer to a new, empty hash table.
  */
-struct HashTable *NewHashTable(void)
+struct _mesa_HashTable *_mesa_NewHashTable(void)
 {
-   return CALLOC_STRUCT(HashTable);
+   return CALLOC_STRUCT(_mesa_HashTable);
 }
 
 
@@ -70,7 +72,7 @@ struct HashTable *NewHashTable(void)
 /*
  * Delete a hash table.
  */
-void DeleteHashTable(struct HashTable *table)
+void _mesa_DeleteHashTable(struct _mesa_HashTable *table)
 {
    GLuint i;
    assert(table);
@@ -93,7 +95,7 @@ void DeleteHashTable(struct HashTable *table)
  *         key - the key
  * Return:  user data pointer or NULL if key not in table
  */
-void *HashLookup(const struct HashTable *table, GLuint key)
+void *_mesa_HashLookup(const struct _mesa_HashTable *table, GLuint key)
 {
    GLuint pos;
    const struct HashEntry *entry;
@@ -121,7 +123,7 @@ void *HashLookup(const struct HashTable *table, GLuint key)
  *         key - the key (not zero)
  *         data - pointer to user data
  */
-void HashInsert(struct HashTable *table, GLuint key, void *data)
+void _mesa_HashInsert(struct _mesa_HashTable *table, GLuint key, void *data)
 {
    /* search for existing entry with this key */
    GLuint pos;
@@ -130,6 +132,8 @@ void HashInsert(struct HashTable *table, GLuint key, void *data)
    assert(table);
    assert(key);
 
+   _glthread_LOCK_MUTEX(table->Mutex);
+
    if (key > table->MaxKey)
       table->MaxKey = key;
 
@@ -139,6 +143,7 @@ void HashInsert(struct HashTable *table, GLuint key, void *data)
       if (entry->Key == key) {
          /* replace entry's data */
         entry->Data = data;
+         _glthread_UNLOCK_MUTEX(table->Mutex);
         return;
       }
       entry = entry->Next;
@@ -150,6 +155,8 @@ void HashInsert(struct HashTable *table, GLuint key, void *data)
    entry->Data = data;
    entry->Next = table->Table[pos];
    table->Table[pos] = entry;
+
+   _glthread_UNLOCK_MUTEX(table->Mutex);
 }
 
 
@@ -159,7 +166,7 @@ void HashInsert(struct HashTable *table, GLuint key, void *data)
  * Input:  table - the hash table
  *         key - key of entry to remove
  */
-void HashRemove(struct HashTable *table, GLuint key)
+void _mesa_HashRemove(struct _mesa_HashTable *table, GLuint key)
 {
    GLuint pos;
    struct HashEntry *entry, *prev;
@@ -167,6 +174,8 @@ void HashRemove(struct HashTable *table, GLuint key)
    assert(table);
    assert(key);
 
+   _glthread_LOCK_MUTEX(table->Mutex);
+
    pos = key & (TABLE_SIZE-1);
    prev = NULL;
    entry = table->Table[pos];
@@ -180,28 +189,35 @@ void HashRemove(struct HashTable *table, GLuint key)
             table->Table[pos] = entry->Next;
          }
          FREE(entry);
+         _glthread_UNLOCK_MUTEX(table->Mutex);
         return;
       }
       prev = entry;
       entry = entry->Next;
    }
+
+   _glthread_UNLOCK_MUTEX(table->Mutex);
 }
 
 
 
 /*
  * Return the key of the "first" entry in the hash table.
- * By calling this function until zero is returned we can get
- * the keys of all entries in the table.
+ * This is used in the course of deleting all display lists when
+ * a context is destroyed.
  */
-GLuint HashFirstEntry(const struct HashTable *table)
+GLuint _mesa_HashFirstEntry(struct _mesa_HashTable *table)
 {
    GLuint pos;
    assert(table);
+   _glthread_LOCK_MUTEX(table->Mutex);
    for (pos=0; pos < TABLE_SIZE; pos++) {
-      if (table->Table[pos])
+      if (table->Table[pos]) {
+         _glthread_UNLOCK_MUTEX(table->Mutex);
          return table->Table[pos]->Key;
+      }
    }
+   _glthread_UNLOCK_MUTEX(table->Mutex);
    return 0;
 }
 
@@ -210,7 +226,7 @@ GLuint HashFirstEntry(const struct HashTable *table)
 /*
  * Dump contents of hash table for debugging.
  */
-void HashPrint(const struct HashTable *table)
+void _mesa_HashPrint(const struct _mesa_HashTable *table)
 {
    GLuint i;
    assert(table);
@@ -231,11 +247,13 @@ void HashPrint(const struct HashTable *table)
  *         numKeys - number of keys needed
  * Return:  starting key of free block or 0 if failure
  */
-GLuint HashFindFreeKeyBlock(const struct HashTable *table, GLuint numKeys)
+GLuint _mesa_HashFindFreeKeyBlock(struct _mesa_HashTable *table, GLuint numKeys)
 {
    GLuint maxKey = ~((GLuint) 0);
+   _glthread_LOCK_MUTEX(table->Mutex);
    if (maxKey - numKeys > table->MaxKey) {
       /* the quick solution */
+      _glthread_UNLOCK_MUTEX(table->Mutex);
       return table->MaxKey + 1;
    }
    else {
@@ -244,7 +262,7 @@ GLuint HashFindFreeKeyBlock(const struct HashTable *table, GLuint numKeys)
       GLuint freeStart = 1;
       GLuint key;
       for (key=1; key!=maxKey; key++) {
-        if (HashLookup(table, key)) {
+        if (_mesa_HashLookup(table, key)) {
            /* darn, this key is already in use */
            freeCount = 0;
            freeStart = key+1;
@@ -253,11 +271,13 @@ GLuint HashFindFreeKeyBlock(const struct HashTable *table, GLuint numKeys)
            /* this key not in use, check if we've found enough */
            freeCount++;
            if (freeCount == numKeys) {
+               _glthread_UNLOCK_MUTEX(table->Mutex);
               return freeStart;
            }
         }
       }
       /* cannot allocate a block of numKeys consecutive keys */
+      _glthread_UNLOCK_MUTEX(table->Mutex);
       return 0;
    }
 }
@@ -273,15 +293,15 @@ int main(int argc, char *argv[])
    printf("&a = %p\n", &a);
    printf("&b = %p\n", &b);
 
-   t = NewHashTable();
-   HashInsert(t, 501, &a);
-   HashInsert(t, 10, &c);
-   HashInsert(t, 0xfffffff8, &b);
-   HashPrint(t);
-   printf("Find 501: %p\n", HashLookup(t,501));
-   printf("Find 1313: %p\n", HashLookup(t,1313));
-   printf("Find block of 100: %d\n", HashFindFreeKeyBlock(t, 100));
-   DeleteHashTable(t);
+   t = _mesa_NewHashTable();
+   _mesa_HashInsert(t, 501, &a);
+   _mesa_HashInsert(t, 10, &c);
+   _mesa_HashInsert(t, 0xfffffff8, &b);
+   _mesa_HashPrint(t);
+   printf("Find 501: %p\n", _mesa_HashLookup(t,501));
+   printf("Find 1313: %p\n", _mesa_HashLookup(t,1313));
+   printf("Find block of 100: %d\n", _mesa_HashFindFreeKeyBlock(t, 100));
+   _mesa_DeleteHashTable(t);
 
    return 0;
 }