Changeset: 93192c110811 for MonetDB
URL: http://dev.monetdb.org/hg/MonetDB?cmd=changeset;node=93192c110811
Modified Files:
clients/Tests/exports.stable.out
gdk/gdk_system.c
gdk/gdk_system.h
Branch: default
Log Message:
Undo of changeset 94cb82d10868.
Don't use the atomic instruction implementation for semaphores. There
were a number of problems with this implementation, not least of which
is slow down. A semaphore is used to wait for something, and when
that something happens, you want the waiting thread to start working
right away, not wait until it's done sleeping.
Also there were unexplained crashes on Sun architectures, possibly
because the instructions don't work the same as on Intel/AMD
architectures.
diffs (truncated from 361 to 300 lines):
diff --git a/clients/Tests/exports.stable.out b/clients/Tests/exports.stable.out
--- a/clients/Tests/exports.stable.out
+++ b/clients/Tests/exports.stable.out
@@ -278,10 +278,6 @@ int GDKnr_threads;
void GDKqsort(void *h, void *t, const void *base, size_t n, int hs, int ts,
int tpe);
void GDKqsort_rev(void *h, void *t, const void *base, size_t n, int hs, int
ts, int tpe);
void *GDKrealloc(void *pold, size_t size);
-ATOMIC_TYPE volatile GDKsemacnt;
-MT_Sema *volatile GDKsemalist;
-ATOMIC_TYPE volatile GDKsemasleepcnt;
-ATOMIC_TYPE volatile GDKsemawaitcnt;
void GDKsetenv(str name, str value);
ssize_t GDKstrFromStr(unsigned char *dst, const unsigned char *src, ssize_t
len);
str GDKstrdup(const char *s);
diff --git a/gdk/gdk_system.c b/gdk/gdk_system.c
--- a/gdk/gdk_system.c
+++ b/gdk/gdk_system.c
@@ -71,11 +71,7 @@ MT_Lock MT_system_lock MT_LOCK_INITIALIZ
ATOMIC_TYPE volatile GDKlockcnt;
ATOMIC_TYPE volatile GDKlockcontentioncnt;
ATOMIC_TYPE volatile GDKlocksleepcnt;
-ATOMIC_TYPE volatile GDKsemacnt;
-ATOMIC_TYPE volatile GDKsemawaitcnt;
-ATOMIC_TYPE volatile GDKsemasleepcnt;
MT_Lock * volatile GDKlocklist;
-MT_Sema * volatile GDKsemalist;
/* merge sort of linked list
* these two functions are nearly identical */
@@ -136,59 +132,12 @@ sortlocklist(MT_Lock *l)
return t;
}
-static MT_Sema *
-sortsemalist(MT_Sema *l)
-{
- MT_Sema *r, *t, *ll = NULL;
-
- if (l == NULL || l->next == NULL)
- return l;
- for (t = r = l; t && t->next; t = t->next->next) {
- ll = r;
- r = r->next;
- }
- ll->next = NULL;
- l = sortsemalist(l);
- r = sortsemalist(r);
- t = ll = NULL;
- while (l && r) {
- if (l->waitcount < r->waitcount ||
- (l->waitcount == r->waitcount &&
- l->sleep < r->sleep) ||
- (l->waitcount == r->waitcount &&
- l->sleep == r->sleep &&
- l->count <= r->count)) {
- if (ll == NULL) {
- assert(t == NULL);
- t = ll = l;
- } else {
- ll->next = l;
- ll = ll->next;
- }
- l = l->next;
- } else {
- if (ll == NULL) {
- assert(t == NULL);
- t = ll = r;
- } else {
- ll->next = r;
- ll = ll->next;
- }
- r = r->next;
- }
- }
- ll->next = l ? l : r;
- return t;
-}
-
void
GDKlockstatistics(int what)
{
MT_Lock *l;
- MT_Sema *s;
GDKlocklist = sortlocklist(GDKlocklist);
- GDKsemalist = sortsemalist(GDKsemalist);
for (l = GDKlocklist; l; l = l->next)
if (what == 0 ||
(what == 1 && l->count) ||
@@ -198,16 +147,9 @@ GDKlockstatistics(int what)
l->name ? l->name : "unknown",
l->count, l->contention, l->sleep,
what != 3 && l->lock ? "\tlocked" : "");
- for (s = GDKsemalist; s; s = s->next)
- fprintf(stderr, "#sema %-18s\t" SZFMT "\t" SZFMT "\t" SZFMT
"\n",
- s->name ? s->name : "unknown",
- s->count, s->waitcount, s->sleep);
fprintf(stderr, "#total lock count " SZFMT "\n", (size_t) GDKlockcnt);
fprintf(stderr, "#lock contention " SZFMT "\n", (size_t)
GDKlockcontentioncnt);
fprintf(stderr, "#lock sleep count " SZFMT "\n", (size_t)
GDKlocksleepcnt);
- fprintf(stderr, "#total sema count " SZFMT "\n", (size_t) GDKsemacnt);
- fprintf(stderr, "#sema wait count " SZFMT "\n", (size_t)
GDKsemawaitcnt);
- fprintf(stderr, "#sema sleep count " SZFMT "\n", (size_t)
GDKsemasleepcnt);
}
#endif
@@ -450,6 +392,8 @@ pthread_mutex_unlock(pthread_mutex_t *mu
return ReleaseMutex(*mutex) ? 0 : -1;
}
+#endif
+
void
pthread_sema_init(pthread_sema_t *s, int flag, int nresources)
{
@@ -475,8 +419,6 @@ pthread_sema_down(pthread_sema_t *s)
WaitForSingleObject(*s, INFINITE);
}
-#endif
-
#else /* !defined(HAVE_PTHREAD_H) && defined(_MSC_VER) */
#ifdef HAVE_PTHREAD_SIGMASK
diff --git a/gdk/gdk_system.h b/gdk/gdk_system.h
--- a/gdk/gdk_system.h
+++ b/gdk/gdk_system.h
@@ -192,51 +192,6 @@ typedef pthread_mutex_t MT_Lock;
#define NEED_MT_LOCK_INIT
#endif
-/*
- * @- MT Semaphore API
- */
-#if !defined(HAVE_PTHREAD_H) && defined(_MSC_VER)
-
-typedef HANDLE pthread_sema_t;
-gdk_export void pthread_sema_init(pthread_sema_t *s, int flag, int nresources);
-gdk_export void pthread_sema_destroy(pthread_sema_t *s);
-gdk_export void pthread_sema_up(pthread_sema_t *s);
-gdk_export void pthread_sema_down(pthread_sema_t *s);
-
-#elif defined(_AIX) || defined(__MACH__)
-
-typedef struct {
- int cnt;
- pthread_mutex_t mutex;
- pthread_cond_t cond;
-} pthread_sema_t;
-
-gdk_export void pthread_sema_init(pthread_sema_t *s, int flag, int nresources);
-gdk_export void pthread_sema_destroy(pthread_sema_t *s);
-gdk_export void pthread_sema_up(pthread_sema_t *s);
-gdk_export void pthread_sema_down(pthread_sema_t *s);
-
-#else
-
-#define pthread_sema_t sem_t
-#define pthread_sema_init sem_init
-#define pthread_sema_destroy sem_destroy
-#define pthread_sema_up sem_post
-#define pthread_sema_down(x) while(sem_wait(x))
-
-#endif
-
-typedef pthread_sema_t MT_Sema;
-
-#define MT_sema_init(s, nr, n) \
- do { \
- pthread_sema_init((s), 0, nr); \
- MT_locktrace_set((s), n); \
- } while (0)
-#define MT_sema_destroy(s) pthread_sema_destroy(s)
-#define MT_sema_up(s, n) MT_log(pthread_sema_up(s), (s), "MT_up_sema",
n, stderr)
-#define MT_sema_down(s, n) MT_log_trace(pthread_sema_down(s), (s),
"MT_down_sema", n, stderr, s)
-
#else
/* if NDEBUG is not set, i.e., if assertions are enabled, we maintain
@@ -252,31 +207,15 @@ typedef struct MT_Lock {
#endif
} MT_Lock;
-typedef struct MT_Sema {
- int volatile lock;
- int volatile sema;
-#ifndef NDEBUG
- size_t count;
- size_t waitcount;
- size_t sleep;
- struct MT_Sema * volatile next;
- const char *name;
-#endif
-} MT_Sema;
-
#ifndef NDEBUG
#define MT_LOCK_INITIALIZER(name) = {0, 0, 0, 0, (struct MT_Lock *) -1,
name}
gdk_export void GDKlockstatistics(int);
gdk_export MT_Lock * volatile GDKlocklist;
-gdk_export MT_Sema * volatile GDKsemalist;
gdk_export ATOMIC_TYPE volatile GDKlockcnt;
gdk_export ATOMIC_TYPE volatile GDKlockcontentioncnt;
gdk_export ATOMIC_TYPE volatile GDKlocksleepcnt;
-gdk_export ATOMIC_TYPE volatile GDKsemacnt;
-gdk_export ATOMIC_TYPE volatile GDKsemawaitcnt;
-gdk_export ATOMIC_TYPE volatile GDKsemasleepcnt;
#ifdef _MSC_VER
#if SIZEOF_SIZE_T == 8
#define ATOMIC_XCG_ptr(var, val) _InterlockedExchangePointer(&(var),
(val))
@@ -335,48 +274,6 @@ gdk_export ATOMIC_TYPE volatile GDKsemas
} \
} while (!_done); \
} while (0)
-#define _DBG_SEMA_INIT(s, n) \
- do { \
- (s)->name = n; \
- (s)->count = 0; \
- (s)->waitcount = 0; \
- (s)->sleep = 0; \
- (s)->next = ATOMIC_XCG_ptr(GDKsemalist, (s)); \
- } while (0)
-#define _DBG_SEMA_DESTROY(s) \
- do { \
- MT_Sema * volatile _p; \
- int _done = 0; \
- /* save a copy for statistical purposes */ \
- _p = GDKmalloc(sizeof(MT_Sema)); \
- memcpy(_p, s, sizeof(MT_Sema)); \
- _p->next = ATOMIC_XCG_ptr(GDKsemalist, _p); \
- do { \
- if (ATOMIC_CAS_ptr(GDKsemalist, (s), (s)->next) == (s))
\
- break; \
- for (_p = GDKsemalist; _p; _p = _p->next) \
- if (ATOMIC_CAS_ptr(_p->next, (s), (s)->next) ==
(s)) { \
- _done = 1; \
- break; \
- } \
- } while (!_done); \
- } while (0)
-#define _DBG_SEMA_COUNT_0(s, n) ATOMIC_INC(GDKsemacnt, dummy, n)
-#define _DBG_SEMA_COUNT_1(s) ((s)->count++)
-#define _DBG_SEMA_WAIT(s, n) \
- do { \
- (s)->waitcount++; \
- ATOMIC_INC(GDKsemawaitcnt, dummy, n); \
- } while (0)
-#define _DBG_SEMA_SLEEP(s, n) \
- do { \
- if (_spincnt == 1024) \
- ATOMIC_INC(GDKsemasleepcnt, dummy, n); \
- } while (0)
-#define _DBG_SEMA_COUNT_2(s) \
- do { \
- (s)->sleep += _spincnt >= 1024; \
- } while (0)
#else
@@ -389,13 +286,6 @@ gdk_export ATOMIC_TYPE volatile GDKsemas
#define _DBG_LOCK_COUNT_2(l) ((void) 0)
#define _DBG_LOCK_INIT(l, n) ((void) n)
#define _DBG_LOCK_DESTROY(l) ((void) 0)
-#define _DBG_SEMA_INIT(s, n) ((void) n)
-#define _DBG_SEMA_DESTROY(s) ((void) 0)
-#define _DBG_SEMA_COUNT_0(s, n) ((void) n)
-#define _DBG_SEMA_COUNT_1(s) ((void) 0)
-#define _DBG_SEMA_WAIT(s, n) ((void) n)
-#define _DBG_SEMA_SLEEP(s, n) ((void) n)
-#define _DBG_SEMA_COUNT_2(s) ((void) 0)
#endif
@@ -426,43 +316,52 @@ gdk_export ATOMIC_TYPE volatile GDKsemas
/* return 0 on success, -1 on failure to get the lock */
#define MT_lock_try(l) ((ATOMIC_CAS_int((l)->lock, 0, 1, dummy, dummy) == 0) -
1)
+#endif
+
+/*
+ * @- MT Semaphore API
+ */
+#if !defined(HAVE_PTHREAD_H) && defined(_MSC_VER)
+
+typedef HANDLE pthread_sema_t;
+gdk_export void pthread_sema_init(pthread_sema_t *s, int flag, int nresources);
+gdk_export void pthread_sema_destroy(pthread_sema_t *s);
+gdk_export void pthread_sema_up(pthread_sema_t *s);
+gdk_export void pthread_sema_down(pthread_sema_t *s);
+
+#elif defined(_AIX) || defined(__MACH__)
+
+typedef struct {
+ int cnt;
+ pthread_mutex_t mutex;
+ pthread_cond_t cond;
+} pthread_sema_t;
+
+gdk_export void pthread_sema_init(pthread_sema_t *s, int flag, int nresources);
_______________________________________________
checkin-list mailing list
checkin-list@monetdb.org
http://mail.monetdb.org/mailman/listinfo/checkin-list
