glx: Use XSaveContext, delete glxhash.c

libX11 has a perfectly good XID-based hash table we can be using, let's.

Reviewed-by: Emma Anholt <emma@anholt.net>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/18474>

src/glx/dri2_glx.c

@@ -57,8 +57,7 @@
 struct dri2_display
 {
    __GLXDRIdisplay base;
-
+   XContext dri2Hash;
-   __glxHashTable *dri2Hash;
 
    const __DRIextension *loader_extensions[5];
 };
@@ -271,7 +270,7 @@ dri2DestroyDrawable(__GLXDRIdrawable *base)
    struct glx_display *dpyPriv = psc->base.display;
    struct dri2_display *pdp = (struct dri2_display *)dpyPriv->dri2Display;
 
-   __glxHashDelete(pdp->dri2Hash, pdraw->base.xDrawable);
+   XDeleteContext(dpyPriv->dpy, pdraw->base.xDrawable, pdp->dri2Hash);
    (*psc->core->destroyDrawable) (pdraw->driDrawable);
 
    /* If it's a GLX 1.3 drawables, we can destroy the DRI2 drawable
@@ -327,7 +326,7 @@ dri2CreateDrawable(struct glx_screen *base, XID xDrawable,
       return NULL;
    }
 
-   if (__glxHashInsert(pdp->dri2Hash, xDrawable, pdraw)) {
+   if (XSaveContext(psc->base.dpy, xDrawable, pdp->dri2Hash, (void *)pdraw)) {
       (*psc->core->destroyDrawable) (pdraw->driDrawable);
       DRI2DestroyDrawable(psc->base.dpy, xDrawable);
       free(pdraw);
@@ -1248,9 +1247,6 @@ handle_error:
 static void
 dri2DestroyDisplay(__GLXDRIdisplay * dpy)
 {
-   struct dri2_display *pdp = (struct dri2_display *) dpy;
-
-   __glxHashDestroy(pdp->dri2Hash);
    free(dpy);
 }
 
@@ -1261,7 +1257,7 @@ dri2GetGlxDrawableFromXDrawableId(Display *dpy, XID id)
    struct dri2_display *pdp = (struct dri2_display *) d->dri2Display;
    __GLXDRIdrawable *pdraw;
 
-   if (__glxHashLookup(pdp->dri2Hash, id, (void *) &pdraw) == 0)
+   if (XFindContext(dpy, id, pdp->dri2Hash, (void *) &pdraw) == 0)
       return pdraw;
 
    return NULL;
@@ -1301,11 +1297,7 @@ dri2CreateDisplay(Display * dpy)
    pdp->loader_extensions[i++] = &driBackgroundCallable.base;
    pdp->loader_extensions[i++] = NULL;
 
-   pdp->dri2Hash = __glxHashCreate();
+   pdp->dri2Hash = XUniqueContext();
-   if (pdp->dri2Hash == NULL) {
-      free(pdp);
-      return NULL;
-   }
 
    return &pdp->base;
 }

src/glx/dri_common.c

@@ -353,10 +353,10 @@ driFetchDrawable(struct glx_context *gc, GLXDrawable glxDrawable)
       return NULL;
 
    psc = priv->screens[gc->screen];
-   if (priv->drawHash == NULL)
+   if (priv->drawHash == 0)
       return NULL;
 
-   if (__glxHashLookup(priv->drawHash, glxDrawable, (void *) &pdraw) == 0) {
+   if (XFindContext(dpy, glxDrawable, priv->drawHash, (void *) &pdraw) == 0) {
       /* Resurrected, so remove from the alive-query-set if exist. */
       _mesa_set_remove_key(priv->zombieGLXDrawable, pdraw);
 
@@ -413,7 +413,7 @@ driFetchDrawable(struct glx_context *gc, GLXDrawable glxDrawable)
       return NULL;
    }
 
-   if (__glxHashInsert(priv->drawHash, glxDrawable, pdraw)) {
+   if (XSaveContext(dpy, glxDrawable, priv->drawHash, (void *)pdraw)) {
       (*pdraw->destroyDrawable) (pdraw);
       return NULL;
    }
@@ -461,7 +461,7 @@ checkServerGLXDrawableAlive(const struct glx_display *priv)
       /* Fail to query, so the window has been closed. Release the GLXDrawable. */
       if (!__glXGetDrawableAttribute(priv->dpy, drawable, GLX_WIDTH, &dummy)) {
          pdraw->destroyDrawable(pdraw);
-         __glxHashDelete(priv->drawHash, drawable);
+         XDeleteContext(priv->dpy, drawable, priv->drawHash);
          _mesa_set_remove(priv->zombieGLXDrawable, entry);
       }
    }
@@ -474,7 +474,7 @@ releaseDrawable(const struct glx_display *priv, GLXDrawable drawable)
 {
    __GLXDRIdrawable *pdraw;
 
-   if (__glxHashLookup(priv->drawHash, drawable, (void *) &pdraw) == 0) {
+   if (XFindContext(priv->dpy, drawable, priv->drawHash, (void *) &pdraw) == 0) {
       /* Only native window and pbuffer have same GLX and X11 drawable ID. */
       if (pdraw->drawable == pdraw->xDrawable) {
          pdraw->refcount --;
@@ -488,7 +488,7 @@ releaseDrawable(const struct glx_display *priv, GLXDrawable drawable)
                _mesa_set_add(priv->zombieGLXDrawable, pdraw);
             } else {
                pdraw->destroyDrawable(pdraw);
-               __glxHashDelete(priv->drawHash, drawable);
+               XDeleteContext(priv->dpy, drawable, priv->drawHash);
             }
          }
       }

src/glx/glx_pbuffer.c

@@ -195,7 +195,7 @@ CreateDRIDrawable(Display *dpy, struct glx_config *config,
       return GL_FALSE;
    }
 
-   if (__glxHashInsert(priv->drawHash, glxdrawable, pdraw)) {
+   if (XSaveContext(dpy, glxdrawable, priv->drawHash, (void *)pdraw)) {
       (*pdraw->destroyDrawable) (pdraw);
       return GL_FALSE;
    }
@@ -218,7 +218,7 @@ DestroyDRIDrawable(Display *dpy, GLXDrawable drawable)
 
    if (priv != NULL && pdraw != NULL) {
       (*pdraw->destroyDrawable) (pdraw);
-      __glxHashDelete(priv->drawHash, drawable);
+      XDeleteContext(dpy, drawable, priv->drawHash);
    }
 #endif
 }

src/glx/glxclient.h

@@ -41,6 +41,7 @@
 #include <X11/Xlibint.h>
 #include <X11/Xfuncproto.h>
 #include <X11/extensions/extutil.h>
+#include <X11/Xresource.h>
 #define GLX_GLXEXT_PROTOTYPES
 #include <GL/glx.h>
 #include <GL/glxext.h>
@@ -51,7 +52,6 @@
 #include <pthread.h>
 #include "GL/glxproto.h"
 #include "glxconfig.h"
-#include "glxhash.h"
 #include "util/macros.h"
 #include "util/u_thread.h"
 #include "util/set.h"
@@ -589,10 +589,10 @@ struct glx_display
      */
    struct glx_screen **screens;
 
-   __glxHashTable *glXDrawHash;
+   XContext glXDrawHash;
 
 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
-   __glxHashTable *drawHash;
+   XContext drawHash;
 
    /**
     * GLXDrawable created from native window and about to be released.

src/glx/glxcmds.c

@@ -79,7 +79,7 @@ GetGLXDRIDrawable(Display * dpy, GLXDrawable drawable)
    if (priv == NULL)
       return NULL;
 
-   if (__glxHashLookup(priv->drawHash, drawable, (void *) &pdraw) == 0)
+   if (XFindContext(dpy, drawable, priv->drawHash, (void *) &pdraw) == 0)
       return pdraw;
 
    return NULL;
@@ -96,7 +96,7 @@ GetGLXDrawable(Display *dpy, GLXDrawable drawable)
    if (priv == NULL)
       return NULL;
 
-   if (__glxHashLookup(priv->glXDrawHash, drawable, (void *) &glxDraw) == 0)
+   if (XFindContext(dpy, drawable, priv->glXDrawHash, (void *) &glxDraw) == 0)
       return glxDraw;
 
    return NULL;
@@ -116,7 +116,7 @@ InitGLXDrawable(Display *dpy, struct glx_drawable *glxDraw, XID xDrawable,
    glxDraw->lastEventSbc = 0;
    glxDraw->eventSbcWrap = 0;
 
-   return __glxHashInsert(priv->glXDrawHash, drawable, glxDraw);
+   return XSaveContext(dpy, drawable, priv->glXDrawHash, (void *)glxDraw);
 }
 
 _X_HIDDEN void
@@ -129,7 +129,7 @@ DestroyGLXDrawable(Display *dpy, GLXDrawable drawable)
       return;
 
    glxDraw = GetGLXDrawable(dpy, drawable);
-   __glxHashDelete(priv->glXDrawHash, drawable);
+   XDeleteContext(dpy, drawable, priv->glXDrawHash);
    free(glxDraw);
 }
 
@@ -763,7 +763,7 @@ glXCreateGLXPixmap(Display * dpy, XVisualInfo * vis, Pixmap pixmap)
          break;
       }
 
-      if (__glxHashInsert(priv->drawHash, xid, pdraw)) {
+      if (XSaveContext(dpy, xid, priv->drawHash, (void *)pdraw)) {
          (*pdraw->destroyDrawable) (pdraw);
          xid = None;
          break;
@@ -822,7 +822,7 @@ glXDestroyGLXPixmap(Display * dpy, GLXPixmap glxpixmap)
 
       if (priv != NULL && pdraw != NULL) {
          (*pdraw->destroyDrawable) (pdraw);
-         __glxHashDelete(priv->drawHash, glxpixmap);
+         XDeleteContext(dpy, glxpixmap, priv->drawHash);
       }
    }
 #endif

src/glx/glxext.c

@@ -296,11 +296,7 @@ glx_display_free(struct glx_display *priv)
 
    FreeScreenConfigs(priv);
 
-   __glxHashDestroy(priv->glXDrawHash);
-
 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
-   __glxHashDestroy(priv->drawHash);
-
    /* Free the direct rendering per display data */
    if (priv->driswDisplay)
       (*priv->driswDisplay->destroyDisplay) (priv->driswDisplay);
@@ -921,7 +917,7 @@ __glXInitialize(Display * dpy)
    XESetCloseDisplay(dpy, dpyPriv->codes.extension, __glXCloseDisplay);
    XESetErrorString (dpy, dpyPriv->codes.extension, __glXErrorString);
 
-   dpyPriv->glXDrawHash = __glxHashCreate();
+   dpyPriv->glXDrawHash = XUniqueContext();
 
 #if defined(GLX_DIRECT_RENDERING) && !defined(GLX_USE_APPLEGL)
    glx_direct = !env_var_as_boolean("LIBGL_ALWAYS_INDIRECT", false);
@@ -930,7 +926,7 @@ __glXInitialize(Display * dpy)
    const char *env = getenv("MESA_LOADER_DRIVER_OVERRIDE");
    zink = env && !strcmp(env, "zink");
 
-   dpyPriv->drawHash = __glxHashCreate();
+   dpyPriv->drawHash = XUniqueContext();
 
    dpyPriv->zombieGLXDrawable = _mesa_pointer_set_create(NULL);
 

src/glx/glxhash.c

@@ -1,473 +0,0 @@
-/* glxhash.c -- Small hash table support for integer -> integer mapping
- * Taken from libdrm.
- *
- * Created: Sun Apr 18 09:35:45 1999 by faith@precisioninsight.com
- *
- * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
- * 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"),
- * to deal in the Software without restriction, including without limitation
- * the rights to use, copy, modify, merge, publish, distribute, sublicense,
- * and/or sell copies of the Software, and to permit persons to whom the
- * Software is furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice (including the next
- * paragraph) shall be included in all copies or substantial portions of the
- * Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
- * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
- * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
- * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
- * DEALINGS IN THE SOFTWARE.
- *
- * Authors: Rickard E. (Rik) Faith <faith@valinux.com>
- *
- * DESCRIPTION
- *
- * This file contains a straightforward implementation of a fixed-sized
- * hash table using self-organizing linked lists [Knuth73, pp. 398-399] for
- * collision resolution.  There are two potentially interesting things
- * about this implementation:
- *
- * 1) The table is power-of-two sized.  Prime sized tables are more
- * traditional, but do not have a significant advantage over power-of-two
- * sized table, especially when double hashing is not used for collision
- * resolution.
- *
- * 2) The hash computation uses a table of random integers [Hanson97,
- * pp. 39-41].
- *
- * FUTURE ENHANCEMENTS
- *
- * With a table size of 512, the current implementation is sufficient for a
- * few hundred keys.  Since this is well above the expected size of the
- * tables for which this implementation was designed, the implementation of
- * dynamic hash tables was postponed until the need arises.  A common (and
- * naive) approach to dynamic hash table implementation simply creates a
- * new hash table when necessary, rehashes all the data into the new table,
- * and destroys the old table.  The approach in [Larson88] is superior in
- * two ways: 1) only a portion of the table is expanded when needed,
- * distributing the expansion cost over several insertions, and 2) portions
- * of the table can be locked, enabling a scalable thread-safe
- * implementation.
- *
- * REFERENCES
- *
- * [Hanson97] David R. Hanson.  C Interfaces and Implementations:
- * Techniques for Creating Reusable Software.  Reading, Massachusetts:
- * Addison-Wesley, 1997.
- *
- * [Knuth73] Donald E. Knuth. The Art of Computer Programming.  Volume 3:
- * Sorting and Searching.  Reading, Massachusetts: Addison-Wesley, 1973.
- *
- * [Larson88] Per-Ake Larson. "Dynamic Hash Tables".  CACM 31(4), April
- * 1988, pp. 446-457.
- *
- */
-
-#include "glxhash.h"
-#include <X11/Xfuncproto.h>
-
-#define HASH_MAIN 0
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define HASH_MAGIC 0xdeadbeef
-#define HASH_DEBUG 0
-#define HASH_SIZE  512          /* Good for about 100 entries */
-                                /* If you change this value, you probably
-                                   have to change the HashHash hashing
-                                   function! */
-
-#define HASH_ALLOC malloc
-#define HASH_FREE  free
-#ifndef HAVE_RANDOM_R
-#define HASH_RANDOM_DECL	char *ps, rs[256]
-#define HASH_RANDOM_INIT(seed)	ps = initstate(seed, rs, sizeof(rs))
-#define HASH_RANDOM		random()
-#define HASH_RANDOM_DESTROY	setstate(ps)
-#else
-#define HASH_RANDOM_DECL	struct random_data rd; int32_t rv; char rs[256]
-#define HASH_RANDOM_INIT(seed)					\
-   do {								\
-      (void) memset(&rd, 0, sizeof(rd));			\
-      (void) initstate_r(seed, rs, sizeof(rs), &rd);		\
-   } while(0)
-#define HASH_RANDOM             ((void) random_r(&rd, &rv), rv)
-#define HASH_RANDOM_DESTROY
-#endif
-
-typedef struct __glxHashBucket
-{
-   unsigned long key;
-   void *value;
-   struct __glxHashBucket *next;
-} __glxHashBucket, *__glxHashBucketPtr;
-
-typedef struct __glxHashTable *__glxHashTablePtr;
-struct __glxHashTable
-{
-   unsigned long magic;
-   unsigned long hits;          /* At top of linked list */
-   unsigned long partials;      /* Not at top of linked list */
-   unsigned long misses;        /* Not in table */
-   __glxHashBucketPtr buckets[HASH_SIZE];
-   int p0;
-   __glxHashBucketPtr p1;
-};
-
-static unsigned long
-HashHash(unsigned long key)
-{
-   unsigned long hash = 0;
-   unsigned long tmp = key;
-   static int init = 0;
-   static unsigned long scatter[256];
-   int i;
-
-   if (!init) {
-      HASH_RANDOM_DECL;
-      HASH_RANDOM_INIT(37);
-      for (i = 0; i < 256; i++)
-         scatter[i] = HASH_RANDOM;
-      HASH_RANDOM_DESTROY;
-      ++init;
-   }
-
-   while (tmp) {
-      hash = (hash << 1) + scatter[tmp & 0xff];
-      tmp >>= 8;
-   }
-
-   hash %= HASH_SIZE;
-#if HASH_DEBUG
-   printf("Hash(%d) = %d\n", key, hash);
-#endif
-   return hash;
-}
-
-_X_HIDDEN __glxHashTable *
-__glxHashCreate(void)
-{
-   __glxHashTablePtr table;
-   int i;
-
-   table = HASH_ALLOC(sizeof(*table));
-   if (!table)
-      return NULL;
-   table->magic = HASH_MAGIC;
-   table->hits = 0;
-   table->partials = 0;
-   table->misses = 0;
-
-   for (i = 0; i < HASH_SIZE; i++)
-      table->buckets[i] = NULL;
-   return table;
-}
-
-_X_HIDDEN int
-__glxHashDestroy(__glxHashTable * t)
-{
-   __glxHashTablePtr table = (__glxHashTablePtr) t;
-   __glxHashBucketPtr bucket;
-   __glxHashBucketPtr next;
-   int i;
-
-   if (table->magic != HASH_MAGIC)
-      return -1;                /* Bad magic */
-
-   for (i = 0; i < HASH_SIZE; i++) {
-      for (bucket = table->buckets[i]; bucket;) {
-         next = bucket->next;
-         HASH_FREE(bucket);
-         bucket = next;
-      }
-   }
-   HASH_FREE(table);
-   return 0;
-}
-
-/* Find the bucket and organize the list so that this bucket is at the
-   top. */
-
-static __glxHashBucketPtr
-HashFind(__glxHashTablePtr table, unsigned long key, unsigned long *h)
-{
-   unsigned long hash = HashHash(key);
-   __glxHashBucketPtr prev = NULL;
-   __glxHashBucketPtr bucket;
-
-   if (h)
-      *h = hash;
-
-   for (bucket = table->buckets[hash]; bucket; bucket = bucket->next) {
-      if (bucket->key == key) {
-         if (prev) {
-            /* Organize */
-            prev->next = bucket->next;
-            bucket->next = table->buckets[hash];
-            table->buckets[hash] = bucket;
-            ++table->partials;
-         }
-         else {
-            ++table->hits;
-         }
-         return bucket;
-      }
-      prev = bucket;
-   }
-   ++table->misses;
-   return NULL;
-}
-
-_X_HIDDEN int
-__glxHashLookup(__glxHashTable * t, unsigned long key, void **value)
-{
-   __glxHashTablePtr table = (__glxHashTablePtr) t;
-   __glxHashBucketPtr bucket;
-
-   if (!table || table->magic != HASH_MAGIC)
-      return -1;                /* Bad magic */
-
-   bucket = HashFind(table, key, NULL);
-   if (!bucket)
-      return 1;                 /* Not found */
-   *value = bucket->value;
-   return 0;                    /* Found */
-}
-
-_X_HIDDEN int
-__glxHashInsert(__glxHashTable * t, unsigned long key, void *value)
-{
-   __glxHashTablePtr table = (__glxHashTablePtr) t;
-   __glxHashBucketPtr bucket;
-   unsigned long hash;
-
-   if (table->magic != HASH_MAGIC)
-      return -1;                /* Bad magic */
-
-   if (HashFind(table, key, &hash))
-      return 1;                 /* Already in table */
-
-   bucket = HASH_ALLOC(sizeof(*bucket));
-   if (!bucket)
-      return -1;                /* Error */
-   bucket->key = key;
-   bucket->value = value;
-   bucket->next = table->buckets[hash];
-   table->buckets[hash] = bucket;
-#if HASH_DEBUG
-   printf("Inserted %d at %d/%p\n", key, hash, bucket);
-#endif
-   return 0;                    /* Added to table */
-}
-
-_X_HIDDEN int
-__glxHashDelete(__glxHashTable * t, unsigned long key)
-{
-   __glxHashTablePtr table = (__glxHashTablePtr) t;
-   unsigned long hash;
-   __glxHashBucketPtr bucket;
-
-   if (table->magic != HASH_MAGIC)
-      return -1;                /* Bad magic */
-
-   bucket = HashFind(table, key, &hash);
-
-   if (!bucket)
-      return 1;                 /* Not found */
-
-   table->buckets[hash] = bucket->next;
-   HASH_FREE(bucket);
-   return 0;
-}
-
-_X_HIDDEN int
-__glxHashNext(__glxHashTable * t, unsigned long *key, void **value)
-{
-   __glxHashTablePtr table = (__glxHashTablePtr) t;
-
-   while (table->p0 < HASH_SIZE) {
-      if (table->p1) {
-         *key = table->p1->key;
-         *value = table->p1->value;
-         table->p1 = table->p1->next;
-         return 1;
-      }
-      table->p1 = table->buckets[table->p0];
-      ++table->p0;
-   }
-   return 0;
-}
-
-_X_HIDDEN int
-__glxHashFirst(__glxHashTable * t, unsigned long *key, void **value)
-{
-   __glxHashTablePtr table = (__glxHashTablePtr) t;
-
-   if (table->magic != HASH_MAGIC)
-      return -1;                /* Bad magic */
-
-   table->p0 = 0;
-   table->p1 = table->buckets[0];
-   return __glxHashNext(table, key, value);
-}
-
-#if HASH_MAIN
-#define DIST_LIMIT 10
-static int dist[DIST_LIMIT];
-
-static void
-clear_dist(void)
-{
-   int i;
-
-   for (i = 0; i < DIST_LIMIT; i++)
-      dist[i] = 0;
-}
-
-static int
-count_entries(__glxHashBucketPtr bucket)
-{
-   int count = 0;
-
-   for (; bucket; bucket = bucket->next)
-      ++count;
-   return count;
-}
-
-static void
-update_dist(int count)
-{
-   if (count >= DIST_LIMIT)
-      ++dist[DIST_LIMIT - 1];
-   else
-      ++dist[count];
-}
-
-static void
-compute_dist(__glxHashTablePtr table)
-{
-   int i;
-   __glxHashBucketPtr bucket;
-
-   printf("Hits = %ld, partials = %ld, misses = %ld\n",
-          table->hits, table->partials, table->misses);
-   clear_dist();
-   for (i = 0; i < HASH_SIZE; i++) {
-      bucket = table->buckets[i];
-      update_dist(count_entries(bucket));
-   }
-   for (i = 0; i < DIST_LIMIT; i++) {
-      if (i != DIST_LIMIT - 1)
-         printf("%5d %10d\n", i, dist[i]);
-      else
-         printf("other %10d\n", dist[i]);
-   }
-}
-
-static void
-check_table(__glxHashTablePtr table, unsigned long key, unsigned long value)
-{
-   unsigned long retval = 0;
-   int retcode = __glxHashLookup(table, key, &retval);
-
-   switch (retcode) {
-   case -1:
-      printf("Bad magic = 0x%08lx:"
-             " key = %lu, expected = %lu, returned = %lu\n",
-             table->magic, key, value, retval);
-      break;
-   case 1:
-      printf("Not found: key = %lu, expected = %lu returned = %lu\n",
-             key, value, retval);
-      break;
-   case 0:
-      if (value != retval)
-         printf("Bad value: key = %lu, expected = %lu, returned = %lu\n",
-                key, value, retval);
-      break;
-   default:
-      printf("Bad retcode = %d: key = %lu, expected = %lu, returned = %lu\n",
-             retcode, key, value, retval);
-      break;
-   }
-}
-
-int
-main(void)
-{
-   __glxHashTablePtr table;
-   int i;
-
-   printf("\n***** 256 consecutive integers ****\n");
-   table = __glxHashCreate();
-   for (i = 0; i < 256; i++)
-      __glxHashInsert(table, i, i);
-   for (i = 0; i < 256; i++)
-      check_table(table, i, i);
-   for (i = 256; i >= 0; i--)
-      check_table(table, i, i);
-   compute_dist(table);
-   __glxHashDestroy(table);
-
-   printf("\n***** 1024 consecutive integers ****\n");
-   table = __glxHashCreate();
-   for (i = 0; i < 1024; i++)
-      __glxHashInsert(table, i, i);
-   for (i = 0; i < 1024; i++)
-      check_table(table, i, i);
-   for (i = 1024; i >= 0; i--)
-      check_table(table, i, i);
-   compute_dist(table);
-   __glxHashDestroy(table);
-
-   printf("\n***** 1024 consecutive page addresses (4k pages) ****\n");
-   table = __glxHashCreate();
-   for (i = 0; i < 1024; i++)
-      __glxHashInsert(table, i * 4096, i);
-   for (i = 0; i < 1024; i++)
-      check_table(table, i * 4096, i);
-   for (i = 1024; i >= 0; i--)
-      check_table(table, i * 4096, i);
-   compute_dist(table);
-   __glxHashDestroy(table);
-
-   printf("\n***** 1024 random integers ****\n");
-   table = __glxHashCreate();
-   srandom(0xbeefbeef);
-   for (i = 0; i < 1024; i++)
-      __glxHashInsert(table, random(), i);
-   srandom(0xbeefbeef);
-   for (i = 0; i < 1024; i++)
-      check_table(table, random(), i);
-   srandom(0xbeefbeef);
-   for (i = 0; i < 1024; i++)
-      check_table(table, random(), i);
-   compute_dist(table);
-   __glxHashDestroy(table);
-
-   printf("\n***** 5000 random integers ****\n");
-   table = __glxHashCreate();
-   srandom(0xbeefbeef);
-   for (i = 0; i < 5000; i++)
-      __glxHashInsert(table, random(), i);
-   srandom(0xbeefbeef);
-   for (i = 0; i < 5000; i++)
-      check_table(table, random(), i);
-   srandom(0xbeefbeef);
-   for (i = 0; i < 5000; i++)
-      check_table(table, random(), i);
-   compute_dist(table);
-   __glxHashDestroy(table);
-
-   return 0;
-}
-#endif

src/glx/glxhash.h

@@ -1,20 +0,0 @@
-#ifndef _GLX_HASH_H_
-#define _GLX_HASH_H_
-
-
-typedef struct __glxHashTable __glxHashTable;
-
-/* Hash table routines */
-extern __glxHashTable *__glxHashCreate(void);
-extern int __glxHashDestroy(__glxHashTable * t);
-extern int __glxHashLookup(__glxHashTable * t, unsigned long key,
-                           void **value);
-extern int __glxHashInsert(__glxHashTable * t, unsigned long key,
-                           void *value);
-extern int __glxHashDelete(__glxHashTable * t, unsigned long key);
-extern int __glxHashFirst(__glxHashTable * t, unsigned long *key,
-                          void **value);
-extern int __glxHashNext(__glxHashTable * t, unsigned long *key,
-                         void **value);
-
-#endif /* _GLX_HASH_H_ */

src/glx/meson.build

@@ -47,8 +47,6 @@ files_libglx = files(
   'glxext.c',
   'glxextensions.c',
   'glxextensions.h',
-  'glxhash.c',
-  'glxhash.h',
   'glx_pbuffer.c',
   'glx_query.c',
   'indirect_glx.c',