can be found in the <literal>sb-thread</literal> package. This is
intended for public consumption, so look at the exported symbols and
their documentation strings.
+</para>
<para>Dynamic bindings to symbols are per-thread. Signal handlers
are per-thread.
+</para>
<para><function>sb-ext:quit</function> exits the current thread, not
necessarily the whole environment. The environment will be shut down
when the last thread exits.
+</para>
<para>Threads arbitrate between themselves for the user's attention.
A thread may be in one of three notional states: foreground,
that thread to find out what it needs. If a background thread enters
the debugger, selecting any restart will put it back into the
background before it resumes.
+</para>
<para>If the user has multiple views onto the same Lisp image (for
example, using multiple terminals, or a windowing system, or network
view has its own collection of foreground/background/stopped threads.
<function>sb-thread:make-listener-thread</function> can be used to
start a new thread in its own `session'.
+</para>
<para>Mutexes and condition variables are available for
managing access to shared data: see
-
<itemizedlist>
<listitem>
<programlisting>(apropos "mutex" :sb-thread)</programlisting>
+</listitem>
<listitem>
<programlisting>(apropos "condition" :sb-thread)</programlisting>
+</listitem>
<listitem> <para>and the <structname>waitqueue</structname> structure
</para>
</listitem>
</itemizedlist>
-
-and poke around in their documentation strings.
+and poke around in their documentation strings.</para>
+</sect3>
<sect3><title>Implementation (Linux x86)</title>
LinuxThreads. &SBCL; threads are mapped 1:1 onto Linux tasks which
share a VM but nothing else - each has its own process id and can be
seen in e.g. <command>ps</command> output.
+</para>
<para>Per-thread local bindings for special variables is achieved
using the %fs segment register to point to a per-thread storage area.
This may cause interesting results if you link to foreign code that
expects threading or creates new threads, and the thread library in
question uses %fs in an incompatible way.
+</para>
<para>Threads waiting on queues (e.g. for locks or condition
variables) are put to sleep using <function>sigtimedwait()</function>
and woken with SIGCONT.
+</para>
<para>&SBCL; at present will alway have at least two tasks running as
seen from Linux: when the first process has done startup
etc) it creates a new thread to run the Lisp startup and initial
listener. The original thread stays around to reap dead subthreads
and deallocate their resources (e.g. stacks) when they exit.
+</para>
<para>Garbage collection is done with the existing Conservative
Generational GC. Allocation is done in small (typically 8k) regions :
streams interface is believed to handle the required system call
restarting correctly, but this may be a consideration when making
other blocking calls e.g. from foreign library code.
+</para>
<para>Large amounts of the &SBCL; library have not been inspected for
thread-safety. Some of the obviously unsafe areas have large locks
around them, so compilation and fasl loading, for example, cannot be
parallelized. Work is ongoing in this area.
+</para>
<para>A new thread by default is created in the same POSIX process
group and session as the thread it was created by. This has an impact
notionally `background'. This is undesirable, so background threads
are set to ignore the SIGINT signal. Arbitration for the input stream
is managed by locking on <varname>sb-thread::*session-lock*</varname>
+</para>
<para>A thread can be created in a new Lisp 'session' (new terminal or
window) using <function>sb-thread:make-listener-thread</function>.
These sessions map directly onto POSIX sessions, so that pressing
Control-C in the wrong window will not interrupt them - this has been
found to be embarrassing.
+</para>
+
+</sect3>
+
+</sect2>
<sect2><title>Support For Unix</>
one argument is implementation-defined. In &SBCL; it calls functions
on the user-settable list <varname>sb-ext:*module-provider-functions*</varname>
- see the <function>require</function> documentation string for details.
+</para>
<para>The toplevel repl prompt may be customized, and the function
that reads user input may be replaced completely. <!-- FIXME but I
don't currently remember how -->
+</para>
+
+</sect2>
<sect2><title>Tools To Help Developers</title>
<chapter id="compiler"><title>The Compiler</>
<para>This chapter will discuss most compiler issues other than
-efficiency, including compiler error messages, the &SBCL compiler's
+efficiency, including compiler error messages, the &SBCL; compiler's
unusual approach to type safety in the presence of type declarations,
the effects of various compiler optimization policies, and the way
that inlining and open coding may cause optimized code to differ from
<sect1><title>The Compiler's Handling of Types</>
<para>The most unusual features of the &SBCL; compiler (which is
-very similar to the original &CMUCL compiler, also known as
+very similar to the original &CMUCL; compiler, also known as
&Python;) is its unusually sophisticated understanding of the
&CommonLisp; type system and its unusually conservative approach to
the implementation of type declarations. These two features reward the
objects through the use of extensions to the Lisp language.
</para></listitem>
</itemizedlist>
+</para>
<para>&SBCL;, like &CMUCL; before it, relies primarily on the
automatic conversion and direct manipulation approaches. The SB-ALIEN
<varname>value</> is an integer. If <varname>value</> is not
supplied, then it defaults to one greater than the value for
the preceding spec (or to zero if it is the first spec.)
- <para>
+ </para>
</listitem>
<listitem>
<para>
</itemizedlist>
+</para>
+
+</sect2>
+
</sect1>
<sect1><title>Operations On Foreign Values</>
<para>See also the <function>sb-alien:with-alien</> macro, which
allocates foreign values on the stack.</para>
+</sect2>
+
</sect1>
<sect1><title>Foreign Variables</>
separately specified by using a list of the form
<programlisting>(alien-string lisp-symbol)</></para></listitem>
</itemizedlist>
+</para>
<synopsis>(sb-alien:define-alien-variable name type)</>
an unevaluated alien type specifier.
</para>
+</sect2>
+
</sect1>
<sect1><title>Foreign Data Structure Examples</>
<listitem><para>Structure type return values are not implemented.</></>
<listitem><para>Passing of structures by value is not implemented.</></>
</itemizedlist>
+</para>
<para>
Here is an example which allocates a <type>(struct foo)</>, calls a foreign
The Lisp function <function>cfoo</> will have
two arguments (<varname>str</> and <varname>a</>)
and two return values (<varname>a</> and <varname>i</>).
+</para>
</sect2>
macro or <function>gc-off</function> call.</para></listitem>
</orderedlist>
+</para>
+
<!-- FIXME: This is a "changebar" section from the CMU CL manual.
I (WHN 2002-07-14) am not very familiar with this content, so
I'm not immediately prepared to try to update it for SBCL, and
LaTeX
-->
+</sect2>
+
</sect1>
<sect1><title>Step-By-Step Example of the Foreign Function Interface</>
printf("s = %s\n", s);
printf("r->x = %d\n", r->x);
printf("r->s = %s\n", r->s);
- for (j = 0; j < 10; j++) printf("a[%d] = %d.\n", j, a[j]);
+ for (j = 0; j < 10; j++) printf("a[%d] = %d.\n", j, a[j]);
r2 = (struct c_struct *) malloc (sizeof(struct c_struct));
r2->x = i + 5;
r2->s = "a C string";
compile the Lisp file. (This step can be done separately. You don't
have to recompile every time.)
<userinput>(compile-file "test.lisp")</>
+</para>
<para>
Within Lisp, load the foreign object file to define the necessary
<userinput>(load-foreign "test.o")</>.
This must be done before loading any code that refers
to these symbols.
-<para>
+</para>
<para>
Now you can load the compiled Lisp ("fasl") file into Lisp:
you'll see in most OO systems, and there are a number of lesser
differences as well. This book tends to help with the culture shock.
</para></listitem>
- <listitem><para></para></listitem>
</itemizedlist>
</para>
at their command prompts. The extensions for functions which
don't have their own command prompt (like <function>trace</>
does) are described in their documentation strings,
- unless your &SBCL was compiled with an option not
+ unless your &SBCL; was compiled with an option not
to include documentation strings, in which case the doc strings
are only readable in the source code.</para></listitem>
<listitem><para>Some low-level information describing the
<!ENTITY CommonLisp "Common Lisp">
<!ENTITY Lisp "Lisp">
- <!-- common expressions I haven't figured out how to express -->
- <!ENTITY mdash "-">
-
<!-- document components -->
<!ENTITY ch-intro SYSTEM "intro.sgml">
<!ENTITY ch-compiler SYSTEM "compiler.sgml">
;;; checkins which aren't released. (And occasionally for internal
;;; versions, especially for internal versions off the main CVS
;;; branch, it gets hairier, e.g. "0.pre7.14.flaky4.13".)
-"0.8.5.24"
+"0.8.5.25"
projects / sbcl.git / commitdiff