URL
https://opencores.org/ocsvn/openrisc/openrisc/trunk
Subversion Repositories openrisc
[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [boehm-gc/] [include/] [private/] [specific.h] - Rev 733
Go to most recent revision | Compare with Previous | Blame | View Log
/* * This is a reimplementation of a subset of the pthread_getspecific/setspecific * interface. This appears to outperform the standard linuxthreads one * by a significant margin. * The major restriction is that each thread may only make a single * pthread_setspecific call on a single key. (The current data structure * doesn't really require that. The restriction should be easily removable.) * We don't currently support the destruction functions, though that * could be done. * We also currently assume that only one pthread_setspecific call * can be executed at a time, though that assumption would be easy to remove * by adding a lock. */ #include <errno.h> /* Called during key creation or setspecific. */ /* For the GC we already hold lock. */ /* Currently allocated objects leak on thread exit. */ /* That's hard to fix, but OK if we allocate garbage */ /* collected memory. */ #define MALLOC_CLEAR(n) GC_INTERNAL_MALLOC(n, NORMAL) #define PREFIXED(name) GC_##name #define TS_CACHE_SIZE 1024 #define CACHE_HASH(n) (((((long)n) >> 8) ^ (long)n) & (TS_CACHE_SIZE - 1)) #define TS_HASH_SIZE 1024 #define HASH(n) (((((long)n) >> 8) ^ (long)n) & (TS_HASH_SIZE - 1)) /* An entry describing a thread-specific value for a given thread. */ /* All such accessible structures preserve the invariant that if either */ /* thread is a valid pthread id or qtid is a valid "quick tread id" */ /* for a thread, then value holds the corresponding thread specific */ /* value. This invariant must be preserved at ALL times, since */ /* asynchronous reads are allowed. */ typedef struct thread_specific_entry { unsigned long qtid; /* quick thread id, only for cache */ void * value; struct thread_specific_entry *next; pthread_t thread; } tse; /* We represent each thread-specific datum as two tables. The first is */ /* a cache, indexed by a "quick thread identifier". The "quick" thread */ /* identifier is an easy to compute value, which is guaranteed to */ /* determine the thread, though a thread may correspond to more than */ /* one value. We typically use the address of a page in the stack. */ /* The second is a hash table, indexed by pthread_self(). It is used */ /* only as a backup. */ /* Return the "quick thread id". Default version. Assumes page size, */ /* or at least thread stack separation, is at least 4K. */ /* Must be defined so that it never returns 0. (Page 0 can't really */ /* be part of any stack, since that would make 0 a valid stack pointer.)*/ static __inline__ unsigned long quick_thread_id() { int dummy; return (unsigned long)(&dummy) >> 12; } #define INVALID_QTID ((unsigned long)0) #define INVALID_THREADID ((pthread_t)0) typedef struct thread_specific_data { tse * volatile cache[TS_CACHE_SIZE]; /* A faster index to the hash table */ tse * hash[TS_HASH_SIZE]; pthread_mutex_t lock; } tsd; typedef tsd * PREFIXED(key_t); extern int PREFIXED(key_create) (tsd ** key_ptr, void (* destructor)(void *)); extern int PREFIXED(setspecific) (tsd * key, void * value); extern void PREFIXED(remove_specific) (tsd * key); /* An internal version of getspecific that assumes a cache miss. */ void * PREFIXED(slow_getspecific) (tsd * key, unsigned long qtid, tse * volatile * cache_entry); static __inline__ void * PREFIXED(getspecific) (tsd * key) { long qtid = quick_thread_id(); unsigned hash_val = CACHE_HASH(qtid); tse * volatile * entry_ptr = key -> cache + hash_val; tse * entry = *entry_ptr; /* Must be loaded only once. */ if (EXPECT(entry -> qtid == qtid, 1)) { GC_ASSERT(entry -> thread == pthread_self()); return entry -> value; } return PREFIXED(slow_getspecific) (key, qtid, entry_ptr); }
Go to most recent revision | Compare with Previous | Blame | View Log