scsh-checkins
[Top] [All Lists]

 Update of /cvsroot/scsh/scsh-0.6/doc/scsh-manual In directory usw-pr-cvs1:/tmp/cvs-serv27735 Modified Files: threads.tex Log Message: Some additions. Index: threads.tex =================================================================== RCS file: /cvsroot/scsh/scsh-0.6/doc/scsh-manual/threads.tex,v retrieving revision 1.1 retrieving revision 1.2 diff -C2 -r1.1 -r1.2 *** threads.tex 2001/07/13 07:12:36 1.1 --- threads.tex 2001/11/13 21:04:15 1.2 *************** *** 24,28 **** documentation is an extension of the file \texttt{doc/threads.txt}. ! The thread package is named \texttt{threads}, it has to be opened explicitly. \defun {spawn} {thunk [name]} \undefined --- 24,28 ---- documentation is an extension of the file \texttt{doc/threads.txt}. ! The thread structure is named \texttt{threads}, it has to be opened explicitly. \defun {spawn} {thunk [name]} \undefined *************** *** 73,77 **** commonly known as \textit{semaphores}. Threads can obtain and release locks. If a thread tries to obtain a lock which is held by another ! thread, the first thread is blocked. \defun{make-lock} {} {lock} --- 73,78 ---- commonly known as \textit{semaphores}. Threads can obtain and release locks. If a thread tries to obtain a lock which is held by another ! thread, the first thread is blocked. To access the following ! procedures, you must open the structure \texttt{locks}. \defun{make-lock} {} {lock} *************** *** 86,90 **** Obtain \var{lock}. Causes the thread to block if the lock is held by ! another thread. \defun{maybe-obtain-lock} {lock} {\boolean} --- 87,91 ---- Obtain \var{lock}. Causes the thread to block if the lock is held by ! a thread. \defun{maybe-obtain-lock} {lock} {\boolean} *************** *** 111,115 **** sets the value of the placeholder. Now all reading threads receive the value and continue executing. Setting a placeholder to two different ! values causes an error. \defun {make-placeholder} {} {placeholder} --- 112,117 ---- sets the value of the placeholder. Now all reading threads receive the value and continue executing. Setting a placeholder to two different ! values causes an error. The structure \texttt{placeholders} features ! the following procedures: \defun {make-placeholder} {} {placeholder} *************** *** 132,136 **** --- 134,191 ---- means of \ex{placeholder-set!}. + \section{The event interface to interrupts} + \label{sec:event-interf-interr} + Scsh provides an synchronous interface to the asynchronous signals + delivered by the operation system\footnote{Olin's paper Automatic + management of operation-system resources'' describes this system in + detail.}. The key element in this system is an object called + \textit{sigevent}, which corresponds to a single occurence of a + signal. A sigevent has two fields: the Unix signal that occurred and a + pointer to the next event that occurred. That is, events are kept in a + linked list in increasing-time order. Scsh provides various procedures + to access this list, they are all procided by the structure + \texttt{sigevents}. + \defun {most-recent-sigevent} {} {sigevent} + + Returns the most recent sigevent, that is, the head of the sigevent + list. + + \defun {sigevent?} {object} {\boolean} + + The predicate for sigevents. + + \defun {next-sigevent} {pre-event type} {event} + + Returns the next sigevent of type \texttt{type} after sigevent + \texttt{pre-event}. If no such event exists, the procdure blocks. + + \defun {next-sigevent-set} {pre-event set} {event} + + Returns the next sigevent whose type is in \texttt{set} after + \texttt{pre-event}. If no such event exists, the procdure blocks. + + \defun {next-sigevent/no-wait} {pre-event type} {event or \sharpf} + + Same as \texttt{next-sigevent}, but returns \sharpf if no appropriate + event exists. + + \defun {next-sigevent-set/no-wait} {set pre-event} {event or \sharpf} + + Same as \texttt{next-sigevent-set}, but returns \sharpf if no appropriate + event exists. + + As a small example, consider this piece of code that toggles the + variable \texttt{state} by USR1 and USR2: + \begin{code} + (define state #t) + + (let lp ((sigevent (most-recent-sigevent))) + (let ((next (next-sigevent sigevent interrupt/usr1))) + (set! state #f) + (let ((next (next-sigevent next interrupt/usr2))) + (set! state #t) + (lp next)))) + \end{code} \section{Interaction between threads and process state} \label{sec:ps_interac} *************** *** 138,143 **** Global process state is a bad thing: it undermines modularity. In the case of concurrency however things get even worse. The simplest ! example for this it the current working directory. If this is global ! state, no thread can ever reliably dereference a relative link. Scsh addresses the problem of process state in a uniform way for --- 193,198 ---- Global process state is a bad thing: it undermines modularity. In the case of concurrency however things get even worse. The simplest ! example for this it the current working directory. If this would be ! global state, no thread can ever reliably dereference a relative link. Scsh addresses the problem of process state in a uniform way for