Changeset 7547 for branches/working-0710

Timestamp:

Oct 29, 2007, 6:50:04 AM (13 years ago)

Author:

gb

Message:

Optionally, use futexes instead of spinlocks when USE_FUTEX is defined.

Log TCR activity via syslog if the environment variable "LOG_TCR_INFO"
is set (value doesn't matter, empty string is OK) on startup.

File:

• branches/working-0710/ccl/lisp-kernel/thread_manager.c (modified) (28 diffs)

branches/working-0710/ccl/lisp-kernel/thread_manager.c

@@ -38 +38 @@
 #endif
 
+void
+log_tcr_initialization(TCR *tcr) {
+  syslog((LOG_USER|LOG_INFO), "created tcr at 0x%lx for thread 0x%lx", tcr, pthread_self());
+}
+
+void
+log_tcr_access(TCR *tcr) {
+  syslog((LOG_USER|LOG_INFO), "accessed tcr at 0x%lx from thread 0x%lx", tcr, pthread_self());
+}
+
+void
+log_tcr_exit(TCR *tcr) {
+  syslog((LOG_USER|LOG_INFO), "thread 0x%lx exiting, had tcr 0x%lx", pthread_self(), tcr);
+}
+
 extern natural
 store_conditional(natural*, natural, natural);
@@ -44 +59 @@
 atomic_swap(signed_natural*, signed_natural);
 
+#ifdef USE_FUTEX
+#define futex_wait(futex,val) syscall(SYS_futex,futex,FUTEX_WAIT,val)
+#define futex_wake(futex,n) syscall(SYS_futex,futex,FUTEX_WAKE,n)
+#define FUTEX_AVAIL (0)
+#define FUTEX_LOCKED (1)
+#define FUTEX_CONTENDED (2)
+#endif
 
 int
@@ -87 +109 @@
 
 
+#ifndef USE_FUTEX
 int spin_lock_tries = 1;
 
@@ -103 +126 @@
   }
 }
-
-
+#endif
+
+#ifndef USE_FUTEX
 int
 lock_recursive_lock(RECURSIVE_LOCK m, TCR *tcr)
@@ -131 +155 @@
 }
 
-  
+#else /* USE_FUTEX */
+
+static void inline
+lock_futex(natural *p)
+{
+  
+  while (1) {
+    if (store_conditional(p,FUTEX_AVAIL,FUTEX_LOCKED) == FUTEX_AVAIL) {
+      return;
+    }
+    while (1) {
+      if (atomic_swap(p,FUTEX_CONTENDED) == FUTEX_AVAIL) {
+        return;
+      }
+      futex_wait(p,FUTEX_CONTENDED);
+    }
+  }
+}
+
+static void inline
+unlock_futex(natural *p)
+{
+  if (atomic_decf(p) != FUTEX_AVAIL) {
+    *p = FUTEX_AVAIL;
+    futex_wake(p,INT_MAX);
+  }
+}
+    
+int
+lock_recursive_lock(RECURSIVE_LOCK m, TCR *tcr)
+{
+  natural val;
+  if (tcr == NULL) {
+    tcr = get_tcr(true);
+  }
+  if (m->owner == tcr) {
+    m->count++;
+    return 0;
+  }
+  lock_futex(&m->avail);
+  m->owner = tcr;
+  m->count = 1;
+  return 0;
+}
+#endif /* USE_FUTEX */
+
+
+#ifndef USE_FUTEX  
 int
 unlock_recursive_lock(RECURSIVE_LOCK m, TCR *tcr)
@@ -163 +234 @@
   return ret;
 }
+#else /* USE_FUTEX */
+int
+unlock_recursive_lock(RECURSIVE_LOCK m, TCR *tcr)
+{
+  int ret = EPERM, pending;
+
+   if (tcr == NULL) {
+    tcr = get_tcr(true);
+  }
+
+  if (m->owner == tcr) {
+    --m->count;
+    if (m->count == 0) {
+      m->owner = NULL;
+      unlock_futex(&m->avail);
+    }
+    ret = 0;
+  }
+  return ret;
+}
+#endif /* USE_FUTEX */
 
 void
 destroy_recursive_lock(RECURSIVE_LOCK m)
 {
+#ifndef USE_FUTEX
   destroy_semaphore((void **)&m->signal);
+#endif
   postGCfree((void *)(m->malloced_ptr));
 }
@@ -177 +271 @@
 */
 
+#ifndef USE_FUTEX
 int
 recursive_lock_trylock(RECURSIVE_LOCK m, TCR *tcr, int *was_free)
@@ -204 +299 @@
   return EBUSY;
 }
+#else
+int
+recursive_lock_trylock(RECURSIVE_LOCK m, TCR *tcr, int *was_free)
+{
+  TCR *owner = m->owner;
+
+  if (owner == tcr) {
+    m->count++;
+    if (was_free) {
+      *was_free = 0;
+      return 0;
+    }
+  }
+  if (store_conditional((natural*)&(m->avail), 0, 1) == 0) {
+    m->owner = tcr;
+    m->count = 1;
+    if (was_free) {
+      *was_free = 1;
+    }
+    return 0;
+  }
+
+  return EBUSY;
+}
+#endif
 
 void
@@ -425 +545 @@
   void *p = calloc(1,sizeof(_recursive_lock)+cache_block_size-1);
   RECURSIVE_LOCK m = NULL;
+#ifndef USE_FUTEX
   void *signal = new_semaphore(0);
+#endif
 
   if (p) {
@@ -432 +554 @@
   }
 
+#ifdef USE_FUTEX
+  if (m) {
+    return m;
+  }
+#else
   if (m && signal) {
     m->signal = signal;
@@ -442 +569 @@
     destroy_semaphore(&signal);
   }
+#endif
   return NULL;
 }
@@ -696 +824 @@
     dequeue_tcr(tcr);
 #endif
+    if (log_tcr_info) {
+      log_tcr_exit(tcr);
+    }
     UNLOCK(lisp_global(TCR_AREA_LOCK),tcr);
     if (termination_semaphore) {
@@ -783 +914 @@
 #endif
   tcr->log2_allocation_quantum = unbox_fixnum(lisp_global(DEFAULT_ALLOCATION_QUANTUM));
+  if (log_tcr_info) {
+    log_tcr_initialization(tcr);
+  }
 }
 
@@ -843 +977 @@
 Boolean threads_initialized = false;
 
+#ifndef USE_FUTEX
 void
 count_cpus()
@@ -866 +1001 @@
 #endif
 }
+#endif
+
+Boolean log_tcr_info = false;
 
 void
@@ -873 +1011 @@
   pthread_key_create((pthread_key_t *)&(lisp_global(TCR_KEY)), shutdown_thread_tcr);
   thread_signal_setup();
+  if (getenv("LOG_TCR_INFO")) {
+    extern char *real_executable_name;
+    log_tcr_info = true;
+    openlog(real_executable_name, LOG_PID, LOG_USER);
+  }
+#ifndef USE_FUTEX
   count_cpus();
+#endif
   threads_initialized = true;
 }
@@ -1055 +1200 @@
 
   }
-  
+  if (log_tcr_info) {
+    log_tcr_access(current);
+  }
   return current;
 }
@@ -1363 +1510 @@
     rw = (rwlock *) ((((natural)p)+cache_block_size-1) & (~(cache_block_size-1)));
     rw->malloced_ptr = p;
+#ifndef USE_FUTEX
     rw->reader_signal = new_semaphore(0);
     rw->writer_signal = new_semaphore(0);
@@ -1374 +1522 @@
       rw = NULL;
     }
+#endif
   }
   return rw;
@@ -1387 +1536 @@
   hold read access once.
 */
+#ifndef USE_FUTEX
 int
 rwlock_rlock(rwlock *rw, TCR *tcr, struct timespec *waitfor)
@@ -1417 +1567 @@
   return err;
 }
-
+#else
+int
+rwlock_rlock(rwlock *rw, TCR *tcr, struct timespec *waitfor)
+{
+  natural waitval;
+
+  lock_futex(&rw->spin);
+
+  if (rw->writer == tcr) {
+    unlock_futex(&rw->spin);
+    return EDEADLOCK;
+  }
+  while (1) {
+    if (rw->writer == NULL) {
+      --rw->state;
+      unlock_futex(&rw->spin);
+      return 0;
+    }
+    rw->blocked_readers++;
+    waitval = rw->reader_signal;
+    unlock_futex(&rw->spin);
+    futex_wait(&rw->reader_signal,waitval);
+    lock_futex(&rw->spin);
+    rw->blocked_readers--;
+  }
+  return 0;
+}
+#endif   
 
 
@@ -1430 +1607 @@
 */
 
+#ifndef USE_FUTEX
 int
 rwlock_wlock(rwlock *rw, TCR *tcr, struct timespec *waitfor)
@@ -1462 +1640 @@
 }
 
+#else
+int
+rwlock_wlock(rwlock *rw, TCR *tcr, struct timespec *waitfor)
+{
+  int err = 0;
+  natural waitval;
+
+  lock_futex(&rw->spin);
+  if (rw->writer == tcr) {
+    rw->state++;
+    unlock_futex(&rw->spin);
+    return 0;
+  }
+
+  while (rw->state != 0) {
+    rw->blocked_writers++;
+    waitval = rw->writer_signal;
+    unlock_futex(&rw->spin);
+    futex_wait(&rw->writer_signal,waitval);
+    lock_futex(&rw->spin);
+    rw->blocked_writers--;
+  }
+  rw->state = 1;
+  rw->writer = tcr;
+  unlock_futex(&rw->spin);
+  return err;
+}
+#endif
+
 /*
   Sort of the same as above, only return EBUSY if we'd have to wait.
 */
+#ifndef USE_FUTEX
 int
 rwlock_try_wlock(rwlock *rw, TCR *tcr)
@@ -1484 +1692 @@
   return ret;
 }
-
+#else
+int
+rwlock_try_wlock(rwlock *rw, TCR *tcr)
+{
+  int ret = EBUSY;
+
+  lock_futex(&rw->spin);
+  if (rw->writer == tcr) {
+    rw->state++;
+    ret = 0;
+  } else {
+    if (rw->state == 0) {
+      rw->writer = tcr;
+      rw->state = 1;
+      ret = 0;
+    }
+  }
+  unlock_futex(&rw->spin);
+  return ret;
+}
+#endif
+
+#ifndef USE_FUTEX
 int
 rwlock_try_rlock(rwlock *rw, TCR *tcr)
@@ -1498 +1728 @@
   return ret;
 }
-
-
-
+#else
+int
+rwlock_try_rlock(rwlock *rw, TCR *tcr)
+{
+  int ret = EBUSY;
+
+  lock_futex(&rw->spin);
+  if (rw->state <= 0) {
+    --rw->state;
+    ret = 0;
+  }
+  unlock_futex(&rw->spin);
+  return ret;
+}
+#endif
+
+
+
+#ifndef USE_FUTEX
 int
 rwlock_unlock(rwlock *rw, TCR *tcr)
@@ -1514 +1760 @@
     } else {
       --rw->state;
+      if (rw->state == 0) {
+        rw->writer = NULL;
+      }
     }
   } else {
@@ -1540 +1789 @@
   return 0;
 }
+#else
+int
+rwlock_unlock(rwlock *rw, TCR *tcr)
+{
+
+  int err = 0;
+
+  lock_futex(&rw->spin);
+  if (rw->state > 0) {
+    if (rw->writer != tcr) {
+      err = EINVAL;
+    } else {
+      --rw->state;
+      if (rw->state == 0) {
+        rw->writer = NULL;
+      }
+    }
+  } else {
+    if (rw->state < 0) {
+      ++rw->state;
+    } else {
+      err = EINVAL;
+    }
+  }
+  if (err) {
+    unlock_futex(&rw->spin);
+    return err;
+  }
+  
+  if (rw->state == 0) {
+    if (rw->blocked_writers) {
+      ++rw->writer_signal;
+      unlock_futex(&rw->spin);
+      futex_wake(&rw->writer_signal,1);
+      return 0;
+    }
+    if (rw->blocked_readers) {
+      ++rw->reader_signal;
+      unlock_futex(&rw->spin);
+      futex_wake(&rw->reader_signal, INT_MAX);
+      return 0;
+    }
+  }
+  unlock_futex(&rw->spin);
+  return 0;
+}
+#endif
 
         
@@ -1545 +1841 @@
 rwlock_destroy(rwlock *rw)
 {
+#ifndef USE_FUTEX
   destroy_semaphore((void **)&rw->reader_signal);
   destroy_semaphore((void **)&rw->writer_signal);
+#endif
   postGCfree((void *)(rw->malloced_ptr));
 }