Dependencies for accelerate-1.3.0.0

Enable debug tracing messages. The following options are read from the environment variable ACCELERATE_FLAGS, and via the command-line as:

./program +ACC ... -ACC

Note that a backend may not implement (or be applicable to) all options.

The following flags control phases of the compiler. The are enabled with -f<flag> and can be reveresed with -fno-<flag>:

• acc-sharing: Enable sharing recovery of array expressions (True).

• exp-sharing: Enable sharing recovery of scalar expressions (True).

• fusion: Enable array fusion (True).

• simplify: Enable program simplification phase (True).

• inplace: Enable in-place array updates (True).

• flush-cache: Clear any persistent caches on program startup (False).

• force-recomp: Force recompilation of array programs (False).

• fast-math: Allow algebraically equivalent transformations which may change floating point results (e.g., reassociate) (True).

• fast-permute-const: Allow non-atomic `permute const` for product types (True).

The following options control debug message output, and are enabled with -d<flag>.

• verbose: Be extra chatty.

• dump-phases: Print timing information about each phase of the compiler. Enable GC stats (+RTS -t or otherwise) for memory usage information.

• dump-sharing: Print information related to sharing recovery.

• dump-simpl-stats: Print statistics related to fusion & simplification.

• dump-simpl-iterations: Print a summary after each simplifier iteration.

• dump-vectorisation: Print information related to the vectoriser.

• dump-dot: Generate a representation of the program graph in Graphviz DOT format.

• dump-simpl-dot: Generate a more compact representation of the program graph in Graphviz DOT format. In particular, scalar expressions are elided.

• dump-gc: Print information related to the Accelerate garbage collector.

• dump-gc-stats: Print aggregate garbage collection information at the end of program execution.

• dubug-cc: Include debug symbols in the generated and compiled kernels.

• dump-cc: Print information related to kernel code generation/compilation. Print the generated code if verbose.

• dump-ld: Print information related to runtime linking.

• dump-asm: Print information related to kernel assembly. Print the assembled code if verbose.

• dump-exec: Print information related to program execution.

• dump-sched: Print information related to execution scheduling.

Enable hooks for monitoring the running application using EKG. Implies debug mode. In order to view the metrics, your application will need to call Data.Array.Accelerate.Debug.beginMonitoring before running any Accelerate computations. This will launch the server on the local machine at port 8000.

Alternatively, if you wish to configure the EKG monitoring server you can initialise it like so:

import Data.Array.Accelerate.Debug

import System.Metrics
import System.Remote.Monitoring

main :: IO ()
main = do
  store  <- initAccMetrics
  registerGcMetrics store      -- optional

  server <- forkServerWith store "localhost" 8000

  ...

Note that, as with any program utilising EKG, in order to collect Haskell GC statistics, you must either run the program with:

+RTS -T -RTS

or compile it with:

-with-rtsopts=-T

Enable bounds checking

Enable bounds checking in unsafe operations

Enable internal consistency checks

Build the nofib test suite (required for backend testing)