the top of your source files, upto the first
(non-literate,non-empty) line not containing
<literal>OPTIONS_GHC</literal>. Multiple <literal>OPTIONS_GHC</literal>
- pragmas are recognised. Note that your command shell does not
+ pragmas are recognised. Do not put comments before, or on the same line
+ as, the <literal>OPTIONS_GHC</literal> pragma.</para>
+
+ <para>Note that your command shell does not
get to the source file options, they are just included literally
- in the array of command-line arguments the compiler driver
+ in the array of command-line arguments the compiler
maintains internally, so you'll be desperately disappointed if
you try to glob etc. inside <literal>OPTIONS_GHC</literal>.</para>
</sect1>
<sect1 id="static-dynamic-flags">
- <title>Static vs. Dynamic options</title>
+ <title>Static, Dynamic, and Mode options</title>
<indexterm><primary>static</primary><secondary>options</secondary>
</indexterm>
<indexterm><primary>dynamic</primary><secondary>options</secondary>
</indexterm>
+ <indexterm><primary>mode</primary><secondary>options</secondary>
+ </indexterm>
<para>Each of GHC's command line options is classified as either
- <firstterm>static</firstterm> or <firstterm>dynamic</firstterm>.
- A static flag may only be specified on the command line, whereas a
- dynamic flag may also be given in an <literal>OPTIONS_GHC</literal>
- pragma in a source file or set from the GHCi command-line with
- <literal>:set</literal>.</para>
-
- <para>As a rule of thumb, options which relate to filenames are
- static, and the rest are dynamic. The flag reference tables (<xref
+ <firstterm>static</firstterm> or <firstterm>dynamic</firstterm> or
+ <firstterm>mode</firstterm>:</para>
+
+ <variablelist>
+ <varlistentry>
+ <term>Mode flags</term>
+ <listitem>
+ <para>For example, <option>--make</option> or <option>-E</option>.
+ There may be only a single mode flag on the command line. The
+ available modes are listed in <xref linkend="modes"/>.</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Dynamic Flags</term>
+ <listitem>
+ <para>Most non-mode flags fall into this category. A dynamic flag
+ may be used on the command line, in a
+ <literal>GHC_OPTIONS</literal> pragma in a source file, or set
+ using <literal>:set</literal> in GHCi.</para>
+ </listitem>
+ </varlistentry>
+ <varlistentry>
+ <term>Static Flags</term>
+ <listitem>
+ <para>A few flags are "static", which means they can only be used on
+ the command-line, and remain in force over the entire GHC/GHCi
+ run.</para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+
+ <para>The flag reference tables (<xref
linkend="flag-reference"/>) lists the status of each flag.</para>
</sect1>
of the compiler, dumping the result in a file. Note that this
differs from the previous behaviour of dumping the file to
standard output.</para>
+
+ <sect3 id="overriding-suffixes">
+ <title>Overriding the default behaviour for a file</title>
+
+ <para>As described above, the way in which a file is processed by GHC
+ depends on its suffix. This behaviour can be overriden using the
+ <option>-x</option> option:</para>
+
+ <variablelist>
+ <varlistentry>
+ <term><option>-x</option> <replaceable>suffix</replaceable>
+ <indexterm><primary><option>-x</option></primary>
+ </indexterm></term>
+ <listitem>
+ <para>Causes all files following this option on the command
+ line to be processed as if they had the suffix
+ <replaceable>suffix</replaceable>. For example, to compile a
+ Haskell module in the file <literal>M.my-hs</literal>,
+ use <literal>ghc -c -x hs M.my-hs</literal>.</para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </sect3>
+
</sect2>
</sect1>
<varlistentry>
<term>
+ <option>-fno-cse</option>
+ <indexterm><primary><option>-fno-cse</option></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Turns off the common-sub-expression elimination optimisation.
+ Can be useful if you have some <literal>unsafePerformIO</literal>
+ expressions that you don't want commoned-up.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
<option>-fno-strictness</option>
<indexterm><primary><option>-fno-strictness</option></primary></indexterm>
</term>
<varlistentry>
<term>
- <option>-fno-cpr-analyse</option>
- <indexterm><primary><option>-fno-cpr-analyse</option></primary></indexterm>
+ <option>-fno-full-laziness</option>
+ <indexterm><primary><option>-fno-full-laziness</option></primary></indexterm>
+ </term>
+ <listitem>
+ <para>Turns off the full laziness optimisation (also known as
+ let-floating). Full laziness increases sharing, which can lead
+ to increased memory residency.</para>
+ </listitem>
+ </varlistentry>
+
+ <varlistentry>
+ <term>
+ <option>-fno-state-hack</option>
+ <indexterm><primary><option>-fno-state-hack</option></primary></indexterm>
</term>
<listitem>
- <para>Turns off the CPR (constructed product result)
- analysis; it is somewhat experimental.</para>
+ <para>Turn off the "state hack" whereby any lambda with a
+ <literal>State#</literal> token as argument is considered to be
+ single-entry, hence it is considered OK to inline things inside
+ it. This can improve performance of IO and ST monad code, but it
+ runs the risk of reducing sharing.</para>
</listitem>
</varlistentry>
&phases;
<sect1 id="sec-using-concurrent">
-<title>Using Concurrent Haskell</title>
-
- <indexterm><primary>Concurrent Haskell—use</primary></indexterm>
+ <title>Using Concurrent Haskell</title>
+ <indexterm><primary>Concurrent Haskell</primary><secondary>using</secondary></indexterm>
-<para>
-GHC supports Concurrent Haskell by default, without requiring a
-special option or libraries compiled in a certain way. To get access
-to the support libraries for Concurrent Haskell, just import
-<literal>Control.Concurrent</literal> (details are in the accompanying
-library documentation).</para>
-
-<para>
-RTS options are provided for modifying the behaviour of the threaded
-runtime system. See <xref linkend="parallel-rts-opts"/>.
-</para>
+ <para>GHC supports Concurrent Haskell by default, without requiring a
+ special option or libraries compiled in a certain way. To get access to
+ the support libraries for Concurrent Haskell, just import
+ <ulink
+ url="../libraries/base/Control-Concurrent.html"><literal>Control.Concurrent</literal></ulink>. More information on Concurrent Haskell is provided in the documentation for that module.</para>
-<para>
-Concurrent Haskell is described in more detail in the documentation
-for the <literal>Control.Concurrent</literal> module.
-</para>
+ <para>The following RTS option(s) affect the behaviour of Concurrent
+ Haskell programs:<indexterm><primary>RTS options, concurrent</primary></indexterm></para>
-</sect1>
+ <variablelist>
+ <varlistentry>
+ <term><option>-C<replaceable>s</replaceable></option></term>
+ <listitem>
+ <para><indexterm><primary><option>-C<replaceable>s</replaceable></option></primary><secondary>RTS option</secondary></indexterm>
+ Sets the context switch interval to <replaceable>s</replaceable>
+ seconds. A context switch will occur at the next heap block
+ allocation after the timer expires (a heap block allocation occurs
+ every 4k of allocation). With <option>-C0</option> or
+ <option>-C</option>, context switches will occur as often as
+ possible (at every heap block allocation). By default, context
+ switches occur every 20ms. Note that GHC's internal timer ticks
+ every 20ms, and the context switch timer is always a multiple of
+ this timer, so 20ms is the maximum granularity available for timed
+ context switches.</para>
+ </listitem>
+ </varlistentry>
+ </variablelist>
+ </sect1>
<sect1 id="sec-using-parallel">
<title>Using parallel Haskell</title>
<para>
-<indexterm><primary>parallel Haskell—use</primary></indexterm>
-</para>
-
-<para>
-[You won't be able to execute parallel Haskell programs unless PVM3
+<indexterm><primary>Parallel Haskell</primary><secondary>using</secondary></indexterm>
+[NOTE: GHC does not support Parallel Haskell by default, you need to
+ obtain a special version of GHC from the <ulink
+ url="http://www.cee.hw.ac.uk/~dsg/gph/">GPH</ulink> site. Also,
+you won't be able to execute parallel Haskell programs unless PVM3
(parallel Virtual Machine, version 3) is installed at your site.]
</para>
<option>-parallel</option> option,<indexterm><primary>-parallel
option</primary></indexterm> both when compiling <emphasis>and
linking</emphasis>. You will probably want to <literal>import
-parallel</literal> into your Haskell modules.
+Control.Parallel</literal> into your Haskell modules.
</para>
<para>
<para>
parallelism profiles (à la <command>hbcpp</command>) can be generated with the
-<option>-qP</option><indexterm><primary>-qP RTS option (concurrent, parallel)</primary></indexterm> RTS option. The
+<option>-qP</option><indexterm><primary>-qP RTS option</primary></indexterm> RTS option. The
per-processor profiling info is dumped into files named
<filename><full-path><program>.gr</filename>. These are then munged into a PostScript picture,
which you can then display. For example, to run your program
</sect2>
<sect2 id="parallel-rts-opts">
-<title>RTS options for Concurrent/parallel Haskell
+<title>RTS options for Parallel Haskell
</title>
<para>
-<indexterm><primary>RTS options, concurrent</primary></indexterm>
<indexterm><primary>RTS options, parallel</primary></indexterm>
-<indexterm><primary>Concurrent Haskell—RTS options</primary></indexterm>
<indexterm><primary>parallel Haskell—RTS options</primary></indexterm>
</para>
<para>
Besides the usual runtime system (RTS) options
(<xref linkend="runtime-control"/>), there are a few options particularly
-for concurrent/parallel execution.
+for parallel execution.
</para>
<para>
</listitem>
</varlistentry>
<varlistentry>
-<term><option>-C[<us>]</option>:</term>
+<term><option>-C[<s>]</option>:</term>
<listitem>
<para>
-<indexterm><primary>-C<us> RTS option</primary></indexterm> Sets
+<indexterm><primary>-C<s> RTS option</primary></indexterm> Sets
the context switch interval to <literal><s></literal> seconds.
A context switch will occur at the next heap block allocation after
the timer expires (a heap block allocation occurs every 4k of
allocation). With <option>-C0</option> or <option>-C</option>,
context switches will occur as often as possible (at every heap block
-allocation). By default, context switches occur every 20ms
-milliseconds. Note that GHC's internal timer ticks every 20ms, and
+allocation). By default, context switches occur every 20ms. Note that GHC's internal timer ticks every 20ms, and
the context switch timer is always a multiple of this timer, so 20ms
is the maximum granularity available for timed context switches.
</para>
<listitem>
<para>
<indexterm><primary>-qt<num> RTS option</primary></indexterm>
-(paraLLEL ONLY) Limit the thread pool size, i.e. the number of concurrent
+(paraLLEL ONLY) Limit the thread pool size, i.e. the number of
threads per processor to <literal><num></literal>. The default is
32. Each thread requires slightly over 1K <emphasis>words</emphasis> in
the heap for thread state and stack objects. (For 32-bit machines, this