From 431ea8f709ef364e350168ba6db2ca5b33b56140 Mon Sep 17 00:00:00 2001 From: Kyle Brenneman Date: Mon, 22 Feb 2016 17:26:54 -0700 Subject: [PATCH] Remove the GLVNDPthreadFuncs parameter from the lkdhash.h macros. The macros in lkdhash.h now just use the __glvndPthreadFuncs table, instead of taking a GLVNDPthreadFuncs parameter. Reviewed-by: Andy Ritger --- include/lkdhash.h | 41 +++++++++++------- src/GLX/libglx.c | 14 +++--- src/GLX/libglxmapping.c | 94 ++++++++++++++++++++--------------------- 3 files changed, 79 insertions(+), 70 deletions(-) diff --git a/include/lkdhash.h b/include/lkdhash.h index 3557515..8dbf3aa 100644 --- a/include/lkdhash.h +++ b/include/lkdhash.h @@ -1,7 +1,16 @@ #ifndef __LKDHASH_H__ #define __LKDHASH_H__ -// This is intended to be used in conjunction with uthash and libglvnd_pthread. +/** + * \file + * + * Macros to implement a hashtable protected by a rwlock. + * + * With the exception of \c DEFINE_LKDHASH and \c DEFINE_INITIALIZED_LKDHASH, + * these macros all use the pthreads function table in glvnd_pthread.h, so you + * have to call \c glvndSetupPthreads before using them. + */ + #include "glvnd_pthread.h" #include "uthash.h" @@ -20,28 +29,28 @@ glvnd_rwlock_t lock; \ } _hashname = { NULL, GLVND_RWLOCK_INITIALIZER } -#define LKDHASH_INIT(imp, _lockedhash) do { \ +#define LKDHASH_INIT(_lockedhash) do { \ (_lockedhash).hash = NULL; \ - (imp).rwlock_init(&(_lockedhash).lock, NULL); \ + __glvndPthreadFuncs.rwlock_init(&(_lockedhash).lock, NULL); \ } while (0) /* * Macros for locking/unlocking the locked hash. */ -#define LKDHASH_RDLOCK(imp, _lockedhash) \ - (imp).rwlock_rdlock(&(_lockedhash).lock) -#define LKDHASH_WRLOCK(imp, _lockedhash) \ - (imp).rwlock_wrlock(&(_lockedhash).lock) -#define LKDHASH_UNLOCK(imp, _lockedhash) \ - (imp).rwlock_unlock(&(_lockedhash).lock) +#define LKDHASH_RDLOCK(_lockedhash) \ + __glvndPthreadFuncs.rwlock_rdlock(&(_lockedhash).lock) +#define LKDHASH_WRLOCK(_lockedhash) \ + __glvndPthreadFuncs.rwlock_wrlock(&(_lockedhash).lock) +#define LKDHASH_UNLOCK(_lockedhash) \ + __glvndPthreadFuncs.rwlock_unlock(&(_lockedhash).lock) /* * Converts a locked hash into a hash suitable for use with uthash. */ #define _LH(_lockedhash) ((_lockedhash).hash) -#define LKDHASH_TEARDOWN_2(imp, _lockedhash, _param, _cur, _tmp, _cleanup) do { \ - LKDHASH_WRLOCK(imp, _lockedhash); \ +#define LKDHASH_TEARDOWN_2(_lockedhash, _param, _cur, _tmp, _cleanup) do { \ + LKDHASH_WRLOCK(_lockedhash); \ HASH_ITER(hh, _LH( _lockedhash), _cur, _tmp) { \ HASH_DEL(_LH(_lockedhash), _cur); \ if (_cleanup) { \ @@ -50,7 +59,7 @@ free(_cur); \ } \ assert(!_LH(_lockedhash)); \ - LKDHASH_UNLOCK(imp, _lockedhash); \ + LKDHASH_UNLOCK(_lockedhash); \ } while (0) /*! @@ -70,16 +79,16 @@ * _reset indicates whether the lock needs to be re-initialized (for fork * handling). */ -#define LKDHASH_TEARDOWN(imp, _ht, _lh, _cleanup, _param, _reset) do { \ +#define LKDHASH_TEARDOWN(_ht, _lh, _cleanup, _param, _reset) do { \ _ht *cur ## _ht, *tmp ## _ht; \ typedef void (*pfnCleanup ## _ht)(void *p, _ht *h); \ pfnCleanup ## _ht pCleanup ## _ht = _cleanup; \ - LKDHASH_TEARDOWN_2(imp, _lh, _param, cur ## _ht, \ + LKDHASH_TEARDOWN_2(_lh, _param, cur ## _ht, \ tmp ## _ht, pCleanup ## _ht); \ if (_reset) { \ - (imp).rwlock_init(&(_lh).lock, NULL); \ + __glvndPthreadFuncs.rwlock_init(&(_lh).lock, NULL); \ } else { \ - (imp).rwlock_destroy(&(_lh).lock); \ + __glvndPthreadFuncs.rwlock_destroy(&(_lh).lock); \ } \ } while (0) diff --git a/src/GLX/libglx.c b/src/GLX/libglx.c index 8dbfeb7..d33cbe0 100644 --- a/src/GLX/libglx.c +++ b/src/GLX/libglx.c @@ -1648,7 +1648,7 @@ void cacheInitializeOnce(void) LOCAL_FUNC_TABLE_ENTRY(glXFreeContextEXT) }; - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXProcAddressHash); + LKDHASH_WRLOCK(__glXProcAddressHash); // Initialize the hash table with our locally-exported functions @@ -1664,7 +1664,7 @@ void cacheInitializeOnce(void) HASH_ADD_KEYPTR(hh, _LH(__glXProcAddressHash), pEntry->procName, strlen((const char *)pEntry->procName), pEntry); } - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXProcAddressHash); + LKDHASH_UNLOCK(__glXProcAddressHash); } @@ -1688,10 +1688,10 @@ static __GLXextFuncPtr __glXGetCachedProcAddress(const GLubyte *procName) __glvndPthreadFuncs.once(&cacheInitializeOnceControl, cacheInitializeOnce); - LKDHASH_RDLOCK(__glvndPthreadFuncs, __glXProcAddressHash); + LKDHASH_RDLOCK(__glXProcAddressHash); HASH_FIND(hh, _LH(__glXProcAddressHash), procName, strlen((const char *)procName), pEntry); - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXProcAddressHash); + LKDHASH_UNLOCK(__glXProcAddressHash); if (pEntry) { return pEntry->addr; @@ -1741,11 +1741,11 @@ static void cacheProcAddress(const GLubyte *procName, __GLXextFuncPtr addr) pEntry->addr = addr; - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXProcAddressHash); + LKDHASH_WRLOCK(__glXProcAddressHash); HASH_ADD_KEYPTR(hh, _LH(__glXProcAddressHash), pEntry->procName, strlen((const char*)pEntry->procName), pEntry); - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXProcAddressHash); + LKDHASH_UNLOCK(__glXProcAddressHash); } PUBLIC __GLXextFuncPtr glXGetProcAddressARB(const GLubyte *procName) @@ -1943,7 +1943,7 @@ static void __glXAPITeardown(Bool doReset) __glvndPthreadFuncs.rwlock_init(&__glXProcAddressHash.lock, NULL); __glvndPthreadFuncs.mutex_init(¤tAPIStateListMutex, NULL); } else { - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXprocAddressHash, + LKDHASH_TEARDOWN(__GLXprocAddressHash, __glXProcAddressHash, CleanupProcAddressEntry, NULL, False); } diff --git a/src/GLX/libglxmapping.c b/src/GLX/libglxmapping.c index 43b856e..d5a9f56 100644 --- a/src/GLX/libglxmapping.c +++ b/src/GLX/libglxmapping.c @@ -154,7 +154,7 @@ static GLboolean AllocDispatchIndex(__GLXvendorInfo *vendor, return GL_FALSE; } - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXDispatchIndexHash); + LKDHASH_WRLOCK(__glXDispatchIndexHash); pEntry->index = __glXNextUnusedHashIndex++; // Notify the vendor this is the index which should be used @@ -162,7 +162,7 @@ static GLboolean AllocDispatchIndex(__GLXvendorInfo *vendor, HASH_ADD_INT(_LH(__glXDispatchIndexHash), index, pEntry); - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXDispatchIndexHash); + LKDHASH_UNLOCK(__glXDispatchIndexHash); return GL_TRUE; } @@ -242,14 +242,14 @@ __GLXextFuncPtr __glXGetGLXDispatchAddress(const GLubyte *procName) // Look through the vendors that we've already loaded, and see if any of // them support the function. - LKDHASH_RDLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_RDLOCK(__glXVendorNameHash); HASH_ITER(hh, _LH(__glXVendorNameHash), pEntry, tmp) { addr = __glXFindVendorDispatchAddress((const char *)procName, pEntry->vendor); if (addr) { break; } } - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_UNLOCK(__glXVendorNameHash); return addr; } @@ -290,7 +290,7 @@ __GLXextFuncPtr __glXFetchDispatchEntry(__GLXvendorInfo *vendor, GLubyte *procName = NULL; __GLXdispatchTableDynamic *dynDispatch = vendor->dynDispatch; - LKDHASH_RDLOCK(__glvndPthreadFuncs, dynDispatch->hash); + LKDHASH_RDLOCK(dynDispatch->hash); HASH_FIND_INT(_LH(dynDispatch->hash), &index, pEntry); @@ -301,7 +301,7 @@ __GLXextFuncPtr __glXFetchDispatchEntry(__GLXvendorInfo *vendor, addr = pEntry->addr; } - LKDHASH_UNLOCK(__glvndPthreadFuncs, dynDispatch->hash); + LKDHASH_UNLOCK(dynDispatch->hash); if (!pEntry) { // Not seen before by this vendor: query the vendor for the right @@ -310,10 +310,10 @@ __GLXextFuncPtr __glXFetchDispatchEntry(__GLXvendorInfo *vendor, __GLXdispatchIndexHash *pdiEntry; // First retrieve the procname of this index - LKDHASH_RDLOCK(__glvndPthreadFuncs, __glXDispatchIndexHash); + LKDHASH_RDLOCK(__glXDispatchIndexHash); HASH_FIND_INT(_LH(__glXDispatchIndexHash), &index, pdiEntry); procName = pdiEntry->procName; - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXDispatchIndexHash); + LKDHASH_UNLOCK(__glXDispatchIndexHash); // This should have a valid entry point associated with it. assert(procName); @@ -323,14 +323,14 @@ __GLXextFuncPtr __glXFetchDispatchEntry(__GLXvendorInfo *vendor, addr = dynDispatch->vendor->glxvc->getProcAddress(procName); } - LKDHASH_WRLOCK(__glvndPthreadFuncs, dynDispatch->hash); + LKDHASH_WRLOCK(dynDispatch->hash); HASH_FIND_INT(_LH(dynDispatch->hash), &index, pEntry); if (!pEntry) { pEntry = malloc(sizeof(*pEntry)); if (!pEntry) { // Uh-oh! assert(pEntry); - LKDHASH_UNLOCK(__glvndPthreadFuncs, dynDispatch->hash); + LKDHASH_UNLOCK(dynDispatch->hash); return NULL; } pEntry->index = index; @@ -340,7 +340,7 @@ __GLXextFuncPtr __glXFetchDispatchEntry(__GLXvendorInfo *vendor, } else { addr = pEntry->addr; } - LKDHASH_UNLOCK(__glvndPthreadFuncs, dynDispatch->hash); + LKDHASH_UNLOCK(dynDispatch->hash); } return addr; @@ -399,7 +399,7 @@ void TeardownVendor(__GLXvendorInfo *vendor, Bool doLibraryUnload) } /* Clean up the dynamic dispatch table */ - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXdispatchFuncHash, + LKDHASH_TEARDOWN(__GLXdispatchFuncHash, vendor->dynDispatch->hash, NULL, NULL, True); free(vendor->dynDispatch); @@ -486,16 +486,16 @@ __GLXvendorInfo *__glXLookupVendorByName(const char *vendorName) return NULL; } - LKDHASH_RDLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_RDLOCK(__glXVendorNameHash); HASH_FIND(hh, _LH(__glXVendorNameHash), vendorName, strlen(vendorName), pEntry); if (pEntry) { vendor = pEntry->vendor; } - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_UNLOCK(__glXVendorNameHash); if (!pEntry) { - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_WRLOCK(__glXVendorNameHash); locked = True; // Do another lookup to check uniqueness HASH_FIND(hh, _LH(__glXVendorNameHash), vendorName, strlen(vendorName), pEntry); @@ -573,12 +573,12 @@ __GLXvendorInfo *__glXLookupVendorByName(const char *vendorName) } /* Initialize the dynamic dispatch table */ - LKDHASH_INIT(__glvndPthreadFuncs, dynDispatch->hash); + LKDHASH_INIT(dynDispatch->hash); dynDispatch->vendor = vendor; HASH_ADD_KEYPTR(hh, _LH(__glXVendorNameHash), vendor->name, strlen(vendor->name), pEntry); - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_UNLOCK(__glXVendorNameHash); // Look up the dispatch functions for any GLX extensions that we // generated entrypoints for. @@ -590,7 +590,7 @@ __GLXvendorInfo *__glXLookupVendorByName(const char *vendorName) } else { /* Some other thread added a vendor */ vendor = pEntry->vendor; - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_UNLOCK(__glXVendorNameHash); } } @@ -598,7 +598,7 @@ __GLXvendorInfo *__glXLookupVendorByName(const char *vendorName) fail: if (locked) { - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXVendorNameHash); + LKDHASH_UNLOCK(__glXVendorNameHash); } if (dlhandle) { dlclose(dlhandle); @@ -736,7 +736,7 @@ static __GLXdisplayInfoHash *InitDisplayInfoEntry(Display *dpy) pEntry->dpy = dpy; pEntry->info.vendors = (__GLXvendorInfo **) (pEntry + 1); - LKDHASH_INIT(__glvndPthreadFuncs, pEntry->info.xidVendorHash); + LKDHASH_INIT(pEntry->info.xidVendorHash); __glvndPthreadFuncs.rwlock_init(&pEntry->info.vendorLock, NULL); // Check whether the server supports the GLX extension, and record the @@ -775,7 +775,7 @@ static void CleanupDisplayInfoEntry(void *unused, __GLXdisplayInfoHash *pEntry) free(pEntry->info.clientStrings[i]); } - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXvendorXIDMappingHash, + LKDHASH_TEARDOWN(__GLXvendorXIDMappingHash, pEntry->info.xidVendorHash, NULL, NULL, False); } @@ -788,9 +788,9 @@ __GLXdisplayInfo *__glXLookupDisplay(Display *dpy) return NULL; } - LKDHASH_RDLOCK(__glvndPthreadFuncs, __glXDisplayInfoHash); + LKDHASH_RDLOCK(__glXDisplayInfoHash); HASH_FIND_PTR(_LH(__glXDisplayInfoHash), &dpy, pEntry); - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXDisplayInfoHash); + LKDHASH_UNLOCK(__glXDisplayInfoHash); if (pEntry != NULL) { return &pEntry->info; @@ -804,7 +804,7 @@ __GLXdisplayInfo *__glXLookupDisplay(Display *dpy) return NULL; } - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXDisplayInfoHash); + LKDHASH_WRLOCK(__glXDisplayInfoHash); HASH_FIND_PTR(_LH(__glXDisplayInfoHash), &dpy, foundEntry); if (foundEntry == NULL) { HASH_ADD_PTR(_LH(__glXDisplayInfoHash), dpy, pEntry); @@ -813,7 +813,7 @@ __GLXdisplayInfo *__glXLookupDisplay(Display *dpy) free(pEntry); pEntry = foundEntry; } - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXDisplayInfoHash); + LKDHASH_UNLOCK(__glXDisplayInfoHash); return &pEntry->info; } @@ -822,12 +822,12 @@ void __glXFreeDisplay(Display *dpy) { __GLXdisplayInfoHash *pEntry = NULL; - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXDisplayInfoHash); + LKDHASH_WRLOCK(__glXDisplayInfoHash); HASH_FIND_PTR(_LH(__glXDisplayInfoHash), &dpy, pEntry); if (pEntry != NULL) { HASH_DEL(_LH(__glXDisplayInfoHash), pEntry); } - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXDisplayInfoHash); + LKDHASH_UNLOCK(__glXDisplayInfoHash); if (pEntry != NULL) { CleanupDisplayInfoEntry(NULL, pEntry); @@ -866,7 +866,7 @@ static void AddVendorPointerMapping(__GLXvendorPointerHashtable *table, return; } - LKDHASH_WRLOCK(__glvndPthreadFuncs, *table); + LKDHASH_WRLOCK(*table); HASH_FIND_PTR(_LH(*table), &ptr, pEntry); @@ -882,7 +882,7 @@ static void AddVendorPointerMapping(__GLXvendorPointerHashtable *table, assert(pEntry->vendor == vendor); } - LKDHASH_UNLOCK(__glvndPthreadFuncs, *table); + LKDHASH_UNLOCK(*table); } static void RemoveVendorPointerMapping(__GLXvendorPointerHashtable *table, void *ptr) @@ -893,7 +893,7 @@ static void RemoveVendorPointerMapping(__GLXvendorPointerHashtable *table, void return; } - LKDHASH_WRLOCK(__glvndPthreadFuncs, *table); + LKDHASH_WRLOCK(*table); HASH_FIND_PTR(_LH(*table), &ptr, pEntry); @@ -902,7 +902,7 @@ static void RemoveVendorPointerMapping(__GLXvendorPointerHashtable *table, void free(pEntry); } - LKDHASH_UNLOCK(__glvndPthreadFuncs, *table); + LKDHASH_UNLOCK(*table); } static int VendorFromPointer(__GLXvendorPointerHashtable *table, void *ptr, @@ -913,7 +913,7 @@ static int VendorFromPointer(__GLXvendorPointerHashtable *table, void *ptr, __glXThreadInitialize(); - LKDHASH_RDLOCK(__glvndPthreadFuncs, *table); + LKDHASH_RDLOCK(*table); HASH_FIND_PTR(_LH(*table), &ptr, pEntry); @@ -921,7 +921,7 @@ static int VendorFromPointer(__GLXvendorPointerHashtable *table, void *ptr, vendor = pEntry->vendor; } - LKDHASH_UNLOCK(__glvndPthreadFuncs, *table); + LKDHASH_UNLOCK(*table); if (retVendor != NULL) { *retVendor = vendor; @@ -1005,7 +1005,7 @@ static void AddVendorXIDMapping(Display *dpy, __GLXdisplayInfo *dpyInfo, XID xid return; } - LKDHASH_WRLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_WRLOCK(dpyInfo->xidVendorHash); HASH_FIND(hh, _LH(dpyInfo->xidVendorHash), &xid, sizeof(xid), pEntry); @@ -1020,7 +1020,7 @@ static void AddVendorXIDMapping(Display *dpy, __GLXdisplayInfo *dpyInfo, XID xid assert(pEntry->vendor == vendor); } - LKDHASH_UNLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_UNLOCK(dpyInfo->xidVendorHash); } @@ -1032,7 +1032,7 @@ static void RemoveVendorXIDMapping(Display *dpy, __GLXdisplayInfo *dpyInfo, XID return; } - LKDHASH_WRLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_WRLOCK(dpyInfo->xidVendorHash); HASH_FIND(hh, _LH(dpyInfo->xidVendorHash), &xid, sizeof(xid), pEntry); @@ -1041,7 +1041,7 @@ static void RemoveVendorXIDMapping(Display *dpy, __GLXdisplayInfo *dpyInfo, XID free(pEntry); } - LKDHASH_UNLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_UNLOCK(dpyInfo->xidVendorHash); } @@ -1051,15 +1051,15 @@ static void VendorFromXID(Display *dpy, __GLXdisplayInfo *dpyInfo, XID xid, __GLXvendorXIDMappingHash *pEntry; __GLXvendorInfo *vendor = NULL; - LKDHASH_RDLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_RDLOCK(dpyInfo->xidVendorHash); HASH_FIND(hh, _LH(dpyInfo->xidVendorHash), &xid, sizeof(xid), pEntry); if (pEntry) { vendor = pEntry->vendor; - LKDHASH_UNLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_UNLOCK(dpyInfo->xidVendorHash); } else { - LKDHASH_UNLOCK(__glvndPthreadFuncs, dpyInfo->xidVendorHash); + LKDHASH_UNLOCK(dpyInfo->xidVendorHash); if (dpyInfo->x11glvndSupported) { int screen = XGLVQueryXIDScreenMapping(dpy, xid); @@ -1146,28 +1146,28 @@ void __glXMappingTeardown(Bool doReset) } } else { /* Tear down all hashtables used in this file */ - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXdispatchIndexHash, + LKDHASH_TEARDOWN(__GLXdispatchIndexHash, __glXDispatchIndexHash, CleanupDispatchIndexEntry, NULL, False); - LKDHASH_WRLOCK(__glvndPthreadFuncs, __glXDispatchIndexHash); + LKDHASH_WRLOCK(__glXDispatchIndexHash); __glXNextUnusedHashIndex = 0; - LKDHASH_UNLOCK(__glvndPthreadFuncs, __glXDispatchIndexHash); + LKDHASH_UNLOCK(__glXDispatchIndexHash); - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXvendorPointerMappingHash, + LKDHASH_TEARDOWN(__GLXvendorPointerMappingHash, contextHashtable, NULL, NULL, False); - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXvendorPointerMappingHash, + LKDHASH_TEARDOWN(__GLXvendorPointerMappingHash, fbconfigHashtable, NULL, NULL, False); - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXdisplayInfoHash, + LKDHASH_TEARDOWN(__GLXdisplayInfoHash, __glXDisplayInfoHash, CleanupDisplayInfoEntry, NULL, False); /* * This implicitly unloads vendor libraries that were loaded when * they were added to this hashtable. */ - LKDHASH_TEARDOWN(__glvndPthreadFuncs, __GLXvendorNameHash, + LKDHASH_TEARDOWN(__GLXvendorNameHash, __glXVendorNameHash, CleanupVendorNameEntry, NULL, False);