]> git.pond.sub.org Git - empserver/blobdiff - src/lib/empthread/pthread.c
Update copyright notice
[empserver] / src / lib / empthread / pthread.c
index fb1e09a93044992224f710dbc3d82aedbc4d392f..7ce03f5e54d7e8e2e3b295bee362ece8bb3ae534 100644 (file)
@@ -1,6 +1,6 @@
 /*
  *  Empire - A multi-player, client/server Internet based war game.
- *  Copyright (C) 1986-2009, Dave Pare, Jeff Bailey, Thomas Ruschak,
+ *  Copyright (C) 1986-2010, Dave Pare, Jeff Bailey, Thomas Ruschak,
  *                           Ken Stevens, Steve McClure
  *
  *  This program is free software; you can redistribute it and/or modify
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <sys/types.h>
-#include <sys/time.h>
+#include <sys/select.h>
 #include <unistd.h>
 #include "misc.h"
 #include "empthread.h"
+#include "file.h"
 #include "prototypes.h"
 
 struct empth_t {
@@ -63,8 +63,12 @@ struct empth_t {
 };
 
 struct empth_rwlock_t {
+    /* Can't use pthread_rwlock_t, because it needn't prefer writers */
     char *name;
-    pthread_rwlock_t lock;
+    int nread;                 /* #active readers */
+    int nwrite;                        /* total #writers (active and waiting) */
+    pthread_cond_t can_read;
+    pthread_cond_t can_write;
 };
 
 /* Thread-specific data key */
@@ -184,6 +188,7 @@ empth_create(void (*entry)(void *), int size, int flags,
     int eno;
 
     empth_status("creating new thread %s", name);
+    ef_make_stale();
 
     ctx = malloc(sizeof(empth_t));
     if (!ctx) {
@@ -259,6 +264,7 @@ empth_exit(void)
     empth_t *ctx = pthread_getspecific(ctx_key);
 
     empth_status("empth_exit");
+    ef_make_stale();
     pthread_mutex_unlock(&mtx_ctxsw);
     free(ctx->name);
     free(ctx);
@@ -268,6 +274,7 @@ empth_exit(void)
 void
 empth_yield(void)
 {
+    ef_make_stale();
     pthread_mutex_unlock(&mtx_ctxsw);
     pthread_mutex_lock(&mtx_ctxsw);
     empth_restorectx();
@@ -283,6 +290,7 @@ empth_select(int fd, int flags, struct timeval *timeout)
     empth_t *ctx;
     int res = 0;
 
+    ef_make_stale();
     pthread_mutex_unlock(&mtx_ctxsw);
     empth_status("select on %d for %d", fd, flags);
 
@@ -346,14 +354,17 @@ int
 empth_sleep(time_t until)
 {
     empth_t *ctx = pthread_getspecific(ctx_key);
+    time_t now;
     struct timeval tv;
     int res;
 
-    empth_status("going to sleep %ld sec", until - time(0));
+    ef_make_stale();
     pthread_mutex_unlock(&mtx_ctxsw);
     do {
-       tv.tv_sec = until - time(NULL);
+       now = time(NULL);
+       tv.tv_sec = until >= now ? until - now : 0;
        tv.tv_usec = 0;
+       empth_status("going to sleep %ld sec", (long)tv.tv_sec);
        res = select(0, NULL, NULL, NULL, &tv);
     } while (res < 0 && !ctx->wakeup);
     empth_status("sleep done. Waiting for lock");
@@ -368,6 +379,7 @@ empth_wait_for_signal(void)
     sigset_t set;
     int sig, err;
 
+    ef_make_stale();
     sigemptyset(&set);
     sigaddset(&set, SIGHUP);
     sigaddset(&set, SIGINT);
@@ -396,19 +408,22 @@ empth_rwlock_create(char *name)
     if (!rwlock)
        return NULL;
 
-    if (pthread_rwlock_init(&rwlock->lock, NULL) != 0) {
+    if (pthread_cond_init(&rwlock->can_read, NULL) != 0
+       || pthread_cond_init(&rwlock->can_write, NULL) != 0) {
        free(rwlock);
        return NULL;
     }
 
     rwlock->name = strdup(name);
+    rwlock->nread = rwlock->nwrite = 0;
     return rwlock;
 }
 
 void
 empth_rwlock_destroy(empth_rwlock_t *rwlock)
 {
-    pthread_rwlock_destroy(&rwlock->lock);
+    pthread_cond_destroy(&rwlock->can_read);
+    pthread_cond_destroy(&rwlock->can_write);
     free(rwlock->name);
     free(rwlock);
 }
@@ -416,23 +431,47 @@ empth_rwlock_destroy(empth_rwlock_t *rwlock)
 void
 empth_rwlock_wrlock(empth_rwlock_t *rwlock)
 {
-    pthread_mutex_unlock(&mtx_ctxsw);
-    pthread_rwlock_wrlock(&rwlock->lock);
-    pthread_mutex_lock(&mtx_ctxsw);
-    empth_restorectx();
+    empth_status("wrlock %s %d %d",
+                rwlock->name, rwlock->nread, rwlock->nwrite);
+    ef_make_stale();
+    rwlock->nwrite++;
+    while (rwlock->nread != 0 || rwlock->nwrite != 1) {
+       empth_status("waiting for wrlock %s", rwlock->name);
+       pthread_cond_wait(&rwlock->can_write, &mtx_ctxsw);
+       empth_status("got wrlock %s %d %d",
+                rwlock->name, rwlock->nread, rwlock->nwrite);
+       empth_restorectx();
+    }
 }
 
 void
 empth_rwlock_rdlock(empth_rwlock_t *rwlock)
 {
-    pthread_mutex_unlock(&mtx_ctxsw);
-    pthread_rwlock_rdlock(&rwlock->lock);
-    pthread_mutex_lock(&mtx_ctxsw);
-    empth_restorectx();
+    empth_status("rdlock %s %d %d",
+                rwlock->name, rwlock->nread, rwlock->nwrite);
+    ef_make_stale();
+    while (rwlock->nwrite) {
+       empth_status("waiting for rdlock %s", rwlock->name);
+       pthread_cond_wait(&rwlock->can_read, &mtx_ctxsw);
+       empth_status("got rdlock %s %d %d",
+                    rwlock->name, rwlock->nread, rwlock->nwrite);
+       empth_restorectx();
+    }
+    rwlock->nread++;
 }
 
 void
 empth_rwlock_unlock(empth_rwlock_t *rwlock)
 {
-    pthread_rwlock_unlock(&rwlock->lock);
+    if (CANT_HAPPEN(!rwlock->nread && !rwlock->nwrite))
+       return;
+    if (rwlock->nread) {       /* holding read lock */
+       if (!--rwlock->nread)
+           pthread_cond_signal(&rwlock->can_write);
+    } else {
+       rwlock->nwrite--;
+       pthread_cond_signal(&rwlock->can_write);
+    }
+    if (rwlock->nwrite == 0)
+       pthread_cond_broadcast(&rwlock->can_read);
 }