X-Git-Url: http://repo.macrolet.net/gitweb/?a=blobdiff_plain;f=doc%2Fbeyond-ansi.sgml;h=c29fd52e68bef1d1b2e4a426b7a600516b5eb832;hb=4ed3f0d08c3a57a6762018d9622f253ab9d0f2b6;hp=b1c0a39a32b301bf7aa883f11018530091b0faed;hpb=abbf4da893fae087978fcdf544c85187ea9c2a9d;p=sbcl.git diff --git a/doc/beyond-ansi.sgml b/doc/beyond-ansi.sgml index b1c0a39..c29fd52 100644 --- a/doc/beyond-ansi.sgml +++ b/doc/beyond-ansi.sgml @@ -48,7 +48,7 @@ of the same symbol more than once is undefined unless the new value is eql to the old value. Conforming to this specification is a nuisance when the "constant" value is only constant under some weaker test like string= or equal. It's -especially annoying because defconstant takes effect +especially annoying because, in &SBCL;, defconstant takes effect not only at load time but also at compile time, so that just compiling and loading reasonable code like (defconstant +foobyte+ '(1 4)) @@ -63,7 +63,11 @@ E.g., the code above can be given an exactly defined meaning by replacing defconstant either with defparameter or with a customized macro which does the right thing, possibly along the lines of the defconstant-eqx macro used internally in the -implementation of SBCL itself. +implementation of &SBCL; itself. In circumstances where this is not +appropriate, the programmer can handle the condition type +sb-ext:defconstant-uneql, and choose either the +continue or abort restart as +appropriate. &SBCL; gives style warnings about various kinds of perfectly legal code, e.g. @@ -110,16 +114,18 @@ calling external C code, described &SBCL; provides additional garbage collection functionality not specified by &ANSI;. Weak pointers allow references to objects to be maintained without keeping them from being GCed. And "finalization" -hooks are available to cause code to be executed when an object is +hooks are available to cause code to be executed when an object has been GCed. &SBCL; supports Gray streams, user-overloadable CLOS classes whose instances can be used as Lisp streams (e.g. passed as the -first argument to format). +first argument to format). Additionally, the +bundled contrib module sb-simple-streams +implements a subset of the Franz Allegro simple-streams proposal. &SBCL; supports a MetaObject Protocol which is intended to be compatible with &AMOP;; present exceptions to this (as distinct from -current bugs) are: +current bugs) are: the abstract metaobject class is not present in the class hierarchy; @@ -131,16 +137,17 @@ current bugs) are: the system-supplied :around method for compute-slots specialized on funcallable-standard-class does not respect the - requested order from a user-supplied primary method. + requested order from a user-supplied primary method. + Threading (a.k.a Multiprocessing)</> -<para>&SBCL; (as of version 0.x.y, on Linux x86 only) supports a +<para>&SBCL; (as of version 0.8.3, on Linux x86 only) supports a fairly low-level threading interface that maps onto the host operating -system's concept of threads or lightweight processes. +system's concept of threads or lightweight processes. </para> <sect3><title>Lisp-level view @@ -148,13 +155,16 @@ system's concept of threads or lightweight processes. can be found in the sb-thread package. This is intended for public consumption, so look at the exported symbols and their documentation strings. + Dynamic bindings to symbols are per-thread. Signal handlers are per-thread. + sb-ext:quit exits the current thread, not necessarily the whole environment. The environment will be shut down when the last thread exits. + Threads arbitrate between themselves for the user's attention. A thread may be in one of three notional states: foreground, @@ -164,6 +174,7 @@ saying that it has stopped. The user at his leisure may switch to 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. + If the user has multiple views onto the same Lisp image (for example, using multiple terminals, or a windowing system, or network @@ -171,21 +182,23 @@ access) they are typically set up as multiple `sessions' such that each view has its own collection of foreground/background/stopped threads. sb-thread:make-listener-thread can be used to start a new thread in its own `session'. + Mutexes and condition variables are available for managing access to shared data: see - (apropos "mutex" :sb-thread) + (apropos "condition" :sb-thread) + and the waitqueue structure - -and poke around in their documentation strings. +and poke around in their documentation strings. + Implementation (Linux x86) @@ -196,39 +209,45 @@ se, but there is plenty wrong (from our perspective) with 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. ps output. + 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. + Threads waiting on queues (e.g. for locks or condition variables) are put to sleep using sigtimedwait() and woken with SIGCONT. + &SBCL; at present will alway have at least two tasks running as seen from Linux: when the first process has done startup initialization (mapping files in place, installing signal handlers -etc) it creates a new thread to run the Lisp startup and initial listener. -The original thread is then used to run GC and to reap dead subthreads -when they exit. +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. + Garbage collection is done with the existing Conservative Generational GC. Allocation is done in small (typically 8k) regions : each thread has its own region so this involves no stopping. However, when a region fills, a lock must be obtained while another is allocated, and when a collection is required, all processes are -stopped. This is achieved using ptrace(), so you -should be very careful if you wish to examine an &SBCL; worker thread -using strace, truss, -gdb or similar. It may be prudent to disable GC -before doing so. +stopped. This is achieved by sending them signals, which may make for +interesting behaviour if they are interrupted in system calls. The +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. + 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. + 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 @@ -237,13 +256,19 @@ on keyboard interrupt handling: pressing your terminal's intr key process group, including Lisp threads that &SBCL; considers to be 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 sb-thread::*session-lock* +is managed by locking on sb-thread::*session-lock* + A thread can be created in a new Lisp 'session' (new terminal or window) using sb-thread:make-listener-thread. 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. + + + + + Support For Unix</> @@ -264,10 +289,14 @@ is also supported.</para> 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 @@ -332,11 +361,9 @@ fixed addresses, a precondition for using copy-on-write to share code between multiple Lisp processes. is less important with modern generational garbage collectors. -The sb-ext:truly-the operator does what the -cl:the operator does in a more conventional -implementation of &CommonLisp;, declaring the type of its argument -without any runtime checks. (Ordinarily in &SBCL;, any type -declaration is treated as an assertion and checked at runtime.) +The sb-ext:truly-the declares the type of the +result of the operations, producing its argument; the declaration is +not checked. In short: don't use it. The sb-ext:freeze-type declaration declares that a type will never change, which can make type testing @@ -349,9 +376,11 @@ to it. This is appropriate for functions like sqrt, but is not appropriate for functions like aref, which can change their return values when the underlying data are changed. + - \ No newline at end of file +