| This is a source code distribution for QuickThreads. QuickThreads is a |
| toolkit for building threads packages; it is described in detail in the |
| University of Washington CS&E Technical report #93-05-06, available via |
| anonymous ftp from `ftp.cs.washington.edu' (128.95.1.4, as of Oct. '94) |
| in `tr/1993/05/UW-CSE-93-05-06.PS.Z'. |
| |
| This distribution shows basic ideas in QuickThreads and elaborates with |
| example implementations for a gaggle of machines. As of October those |
| machines included: |
| |
| 80386 faimly |
| 88000 faimily |
| DEC AXP (Alpha) family |
| HP-PA family |
| KSR |
| MIPS family |
| SPARC V8 family |
| VAX family |
| |
| Configuration, build, and installation are described in INSTALL. |
| |
| Be aware: that there is no varargs code for the KSR. |
| |
| The HP-PA port was designed to work with both HP workstations |
| and Convex SPP computers. It was generously provided by Uwe Reder |
| <uereder@cip.informatik.uni-erlangen.de>. It is part of the ELiTE |
| (Erlangen Lightweight Thread Environment) project directed by |
| Frank Bellosa <bellosa@informatik.uni-erlangen.de> at the Operating |
| Systems Department of the University of Erlangen (Germany). |
| |
| Other contributors include: Weihaw Chuang, Richard O'Keefe, |
| Laurent Perron, John Polstra, Shinji Suzuki, Assar Westerlund, |
| thanks also to Peter Buhr and Dirk Grunwald. |
| |
| |
| Here is a brief summary: |
| |
| QuickThreads is a toolkit for building threads packages. It is my hope |
| that you'll find it easier to use QuickThreads normally than to take it |
| and modify the raw cswap code to fit your application. The idea behind |
| QuickThreads is that it should make it easy for you to write & retarget |
| threads packages. If you want the routine `t_create' to create threads |
| and `t_block' to suspend threads, you write them using the QuickThreads |
| `primitive' operations `QT_SP', `QT_INIT', and `QT_BLOCK', that perform |
| machine-dependent initialization and blocking, plus code you supply for |
| performing the portable operatons. For example, you might write: |
| |
| t_create (func, arg) |
| { |
| stk = malloc (STKSIZE); |
| stackbase = QT_SP (stk, STKSIZE); |
| sp = QT_INIT (stakcbase, func, arg); |
| qput (runq, sp); |
| } |
| |
| Threads block by doing something like: |
| |
| t_block() |
| { |
| sp_next = qget (runq); |
| QT_BLOCK (helper, runq, sp_next); |
| // wake up again here |
| } |
| |
| // called by QT_BLOCK after the old thread has blocked, |
| // puts the old thread on the queue `onq'. |
| helper (sp_old, onq) |
| { |
| qput (onq, sp_old); |
| } |
| |
| (Of course) it's actually a bit more complex than that, but the general |
| idea is that you write portable code to allocate stacks and enqueue and |
| dequeue threads. Than, to get your threads package up and running on a |
| different machine, you just reconfigure QuickThreads and recompile, and |
| that's it. |
| |
| The QuickThreads `distribution' includes a sample threads package (look |
| at stp.{c,h}) that is written in terms of QuickThreads operations. The |
| TR mentioned above explains the simple threads package in detail. |
| |
| |
| |
| If you do use QuickThreads, I'd like to hear both about what worked for |
| you and what didn't work, problems you had, insights gleaned, etc. |
| |
| Let me know what you think. |
| |
| David Keppel <pardo@cs.washington.edu> |
