Repository : ssh://darcs.haskell.org//srv/darcs/ghc

On branch  : master

http://hackage.haskell.org/trac/ghc/changeset/151b0dcd4e16e28d76fbdceadeea7287b49b9e29

>---------------------------------------------------------------

commit 151b0dcd4e16e28d76fbdceadeea7287b49b9e29
Author: Simon Marlow <[email protected]>
Date:   Mon Feb 27 13:33:11 2012 +0000

    Mention -threaded in the intro to Concurrent Haskell
    
    And make the docs a bit more concrete.

>---------------------------------------------------------------

 docs/users_guide/phases.xml |   25 ++++++++++++++++++-------
 docs/users_guide/using.xml  |   29 +++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 7 deletions(-)

diff --git a/docs/users_guide/phases.xml b/docs/users_guide/phases.xml
index f98fe90..d7ad995 100644
--- a/docs/users_guide/phases.xml
+++ b/docs/users_guide/phases.xml
@@ -941,13 +941,24 @@ $ cat foo.hspp</screen>
 
           <itemizedlist>
             <listitem>
-              
<para>Parallelism<indexterm><primary>parallelism</primary></indexterm> on a 
multiprocessor<indexterm><primary>multiprocessor</primary></indexterm><indexterm><primary>SMP</primary></indexterm>
 or multicore<indexterm><primary>multicore</primary></indexterm>
-              machine.  See <xref linkend="using-smp" />.</para>
-
-              <para>The ability to make a foreign call that does not
-              block all other Haskell threads, and to invoke
-              foreign-exported Haskell functions from multiple OS
-              threads. See <xref linkend="ffi-threads" />.</para>
+              <para>It enables the 
<option>-N</option><indexterm><primary><option>-N<replaceable>x</replaceable></option></primary><secondary>RTS
 option</secondary></indexterm> RTS option to be
+                used, which allows threads to run in
+                parallel<indexterm><primary>parallelism</primary></indexterm>
+                on a
+                
multiprocessor<indexterm><primary>multiprocessor</primary></indexterm><indexterm><primary>SMP</primary></indexterm>
+                or
+                multicore<indexterm><primary>multicore</primary></indexterm>
+                machine.  See <xref linkend="using-smp" />.</para>
+            </listitem>
+            <listitem>
+              <para>If a thread makes a foreign call (and the call is
+                not marked <literal>unsafe</literal>), then other
+                Haskell threads in the program will continue to run
+                while the foreign call is in progress.
+                Additionally, <literal>foreign export</literal>ed
+                Haskell functions may be called from multiple OS
+                threads simultaneously.  See
+                <xref linkend="ffi-threads" />.</para>
             </listitem>
           </itemizedlist>
         </listitem>
diff --git a/docs/users_guide/using.xml b/docs/users_guide/using.xml
index 4a99b88..234b64d 100644
--- a/docs/users_guide/using.xml
+++ b/docs/users_guide/using.xml
@@ -2049,6 +2049,35 @@ f "2"    = 2
       <ulink
        
url="&libraryBaseLocation;/Control-Concurrent.html"><literal>Control.Concurrent</literal></ulink>.
  More information on Concurrent Haskell is provided in the documentation for 
that module.</para>
 
+    <para>
+      Optionally, the program may be linked with
+      the <option>-threaded</option> option (see
+      <xref linkend="options-linker" />.  This provides two benefits:
+
+      <itemizedlist>
+        <listitem>
+          <para>It enables the 
<option>-N</option><indexterm><primary><option>-N<replaceable>x</replaceable></option></primary><secondary>RTS
 option</secondary></indexterm> RTS option to be
+            used, which allows threads to run in
+            parallel<indexterm><primary>parallelism</primary></indexterm>
+            on a
+            
multiprocessor<indexterm><primary>multiprocessor</primary></indexterm><indexterm><primary>SMP</primary></indexterm>
+            or
+            multicore<indexterm><primary>multicore</primary></indexterm>
+            machine.  See <xref linkend="using-smp" />.</para>
+        </listitem>
+        <listitem>
+          <para>If a thread makes a foreign call (and the call is
+            not marked <literal>unsafe</literal>), then other
+            Haskell threads in the program will continue to run
+            while the foreign call is in progress.
+            Additionally, <literal>foreign export</literal>ed
+            Haskell functions may be called from multiple OS
+            threads simultaneously.  See
+            <xref linkend="ffi-threads" />.</para>
+        </listitem>
+      </itemizedlist>
+    </para>
+
     <para>The following RTS option(s) affect the behaviour of Concurrent
       Haskell programs:<indexterm><primary>RTS options, 
concurrent</primary></indexterm></para>
 



_______________________________________________
Cvs-ghc mailing list
[email protected]
http://www.haskell.org/mailman/listinfo/cvs-ghc

Reply via email to