accelerate.cabal

Name:                   accelerate
Version:                1.2.0.0
Cabal-version:          >= 1.8
Tested-with:            GHC >= 7.8
Build-type:             Custom

Synopsis:               An embedded language for accelerated array processing

Description:
  @Data.Array.Accelerate@ defines an embedded array language for computations
  for high-performance computing in Haskell. Computations on multi-dimensional,
  regular arrays are expressed in the form of parameterised collective
  operations, such as maps, reductions, and permutations. These computations may
  then be online compiled and executed on a range of architectures.
  .
  [/A simple example/]
  .
  As a simple example, consider the computation of a dot product of two vectors
  of floating point numbers:
  .
  > dotp :: Acc (Vector Float) -> Acc (Vector Float) -> Acc (Scalar Float)
  > dotp xs ys = fold (+) 0 (zipWith (*) xs ys)
  .
  Except for the type, this code is almost the same as the corresponding Haskell
  code on lists of floats. The types indicate that the computation may be
  online-compiled for performance - for example, using
  @Data.Array.Accelerate.LLVM.PTX@ it may be on-the-fly off-loaded to the GPU.
  .
  [/Additional components/]
  .
  The following supported add-ons are available as separate packages. Install
  them from Hackage with @cabal install \<package\>@
  .
    * @accelerate-llvm-native@: Backend supporting parallel execution on
      multicore CPUs.
  .
    * @accelerate-llvm-ptx@: Backend supporting parallel execution on
      CUDA-capable NVIDIA GPUs. Requires a GPU with compute capability 2.0 or
      greater. See the following table for supported GPUs:
      <http://en.wikipedia.org/wiki/CUDA#Supported_GPUs>
  .
    * @accelerate-examples@: Computational kernels and applications showcasing
      the use of Accelerate as well as a regression test suite, supporting
      function and performance testing.
  .
    * @accelerate-io@: Fast conversions between Accelerate arrays and other
      array formats (including vector and repa).
  .
    * @accelerate-fft@: Discrete Fourier transforms, with FFI bindings to
      optimised implementations.
  .
    * @accelerate-bignum@: Fixed-width large integer arithmetic.
  .
    * @colour-accelerate@: Colour representations in Accelerate (RGB, sRGB, HSV,
      and HSL).
  .
    * @gloss-accelerate@: Generate gloss pictures from Accelerate.
  .
    * @gloss-raster-accelerate@: Parallel rendering of raster images and
      animations.
  .
    * @lens-accelerate@: Lens operators for Accelerate types.
  .
    * @linear-accelerate@: Linear vector spaces in Accelerate.
  .
    * @mwc-random-accelerate@: Generate Accelerate arrays filled with high
      quality pseudorandom numbers.
  .
  [/Examples and documentation/]
  .
  Haddock documentation is included in the package
  .
  The @accelerate-examples@ package demonstrates a range of computational
  kernels and several complete applications, including:
  .
    * An implementation of the Canny edge detection algorithm
  .
    * An interactive Mandelbrot set generator
  .
    * A particle-based simulation of stable fluid flows
  .
    * An /n/-body simulation of gravitational attraction between solid particles
  .
    * An implementation of the PageRank algorithm
  .
    * A simple interactive ray tracer
  .
    * A cellular automata simulation
  .
    * A \"password recovery\" tool, for dictionary lookup of MD5 hashes
  .
  @lulesh-accelerate@ is an implementation of the Livermore Unstructured
  Lagrangian Explicit Shock Hydrodynamics (LULESH) mini-app. LULESH represents a
  typical hydrodynamics code such as ALE3D, but is highly simplified and
  hard-coded to solve the Sedov blast problem on an unstructured hexahedron
  mesh.
  .
  [/Mailing list and contacts/]
  .
    * Mailing list: <accelerate-haskell@googlegroups.com> (discussion of both
      use and development welcome).
  .
    * Sign up for the mailing list here:
      <http://groups.google.com/group/accelerate-haskell>
  .
    * Bug reports and issue tracking:
      <https://github.com/AccelerateHS/accelerate/issues>
  .

License:                BSD3
License-file:           LICENSE
Author:                 Manuel M T Chakravarty,
                        Robert Clifton-Everest,
                        Gabriele Keller,
                        Ben Lever,
                        Trevor L. McDonell,
                        Ryan Newtown,
                        Sean Seefried
Maintainer:             Trevor L. McDonell <tmcdonell@cse.unsw.edu.au>
Homepage:               https://github.com/AccelerateHS/accelerate/
Bug-reports:            https://github.com/AccelerateHS/accelerate/issues

Category:               Compilers/Interpreters, Concurrency, Data, Parallelism
Stability:              Experimental

Extra-source-files:
    README.md
    CHANGELOG.md

custom-setup
  setup-depends:
      base              >= 4.7
    , Cabal
    , cabal-doctest     >= 1.0

Flag debug
  Default:              False
  Description:
    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).
    .
      * @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).
    .
    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.
    .

Flag ekg
  Default:              False
  Description:
    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
    .

Flag bounds-checks
  Description:          Enable bounds checking
  Default:              True

Flag unsafe-checks
  Description:          Enable bounds checking in unsafe operations
  Default:              False

Flag internal-checks
  Description:          Enable internal consistency checks
  Default:              False

Library
  Build-depends:
          base                          >= 4.7 && < 4.11
        , ansi-terminal                 >= 0.6.2
        , ansi-wl-pprint                >= 0.6
        , base-orphans                  >= 0.3
        , containers                    >= 0.3
        , deepseq                       >= 1.3
        , directory                     >= 1.0
        , exceptions                    >= 0.6
        , filepath                      >= 1.0
        , ghc-prim
        , hashable                      >= 1.1
        , hashtables                    >= 1.0
        , hedgehog                      >= 0.5
        , mtl                           >= 2.0
        , template-haskell
        , terminal-size                 >= 0.3
        , time                          >= 1.4
        , transformers                  >= 0.3
        , unique
        , unordered-containers          >= 0.2
        , vector                        >= 0.10

  Exposed-modules:
        -- The core language and reference implementation
        Data.Array.Accelerate
        Data.Array.Accelerate.Interpreter

        -- Prelude-like
        Data.Array.Accelerate.Data.Bits
        Data.Array.Accelerate.Data.Complex
        Data.Array.Accelerate.Data.Fold
        Data.Array.Accelerate.Data.Monoid

        -- For backend development
        Data.Array.Accelerate.AST
        Data.Array.Accelerate.Analysis.Hash
        Data.Array.Accelerate.Analysis.Match
        Data.Array.Accelerate.Analysis.Shape
        Data.Array.Accelerate.Analysis.Stencil
        Data.Array.Accelerate.Analysis.Type
        Data.Array.Accelerate.Array.Data
        Data.Array.Accelerate.Array.Remote
        Data.Array.Accelerate.Array.Remote.Class
        Data.Array.Accelerate.Array.Remote.LRU
        Data.Array.Accelerate.Array.Remote.Table
        Data.Array.Accelerate.Array.Representation
        Data.Array.Accelerate.Array.Sugar
        Data.Array.Accelerate.Array.Unique
        Data.Array.Accelerate.Async
        Data.Array.Accelerate.Debug
        Data.Array.Accelerate.Error
        Data.Array.Accelerate.FullList
        Data.Array.Accelerate.Lifetime
        Data.Array.Accelerate.Pretty
        Data.Array.Accelerate.Product
        Data.Array.Accelerate.Smart
        Data.Array.Accelerate.Trafo
        Data.Array.Accelerate.Type

        -- For testing
        Data.Array.Accelerate.Hedgehog.Gen.Shape
        Data.Array.Accelerate.Hedgehog.Gen.Array
        Data.Array.Accelerate.Hedgehog.Similar

  Other-modules:
        Data.Atomic
        Data.Array.Accelerate.Analysis.Hash.TH
        Data.Array.Accelerate.Array.Lifted
        Data.Array.Accelerate.Array.Remote.Nursery
        Data.Array.Accelerate.Classes
        Data.Array.Accelerate.Classes.Bounded
        Data.Array.Accelerate.Classes.Enum
        Data.Array.Accelerate.Classes.Eq
        Data.Array.Accelerate.Classes.Floating
        Data.Array.Accelerate.Classes.Fractional
        Data.Array.Accelerate.Classes.FromIntegral
        Data.Array.Accelerate.Classes.Integral
        Data.Array.Accelerate.Classes.Num
        Data.Array.Accelerate.Classes.Ord
        Data.Array.Accelerate.Classes.Real
        Data.Array.Accelerate.Classes.RealFloat
        Data.Array.Accelerate.Classes.RealFrac
        Data.Array.Accelerate.Classes.ToFloating
        Data.Array.Accelerate.Debug.Flags
        Data.Array.Accelerate.Debug.Monitoring
        Data.Array.Accelerate.Debug.Stats
        Data.Array.Accelerate.Debug.Timed
        Data.Array.Accelerate.Debug.Trace
        Data.Array.Accelerate.Language
        Data.Array.Accelerate.Lift
        Data.Array.Accelerate.Prelude
        Data.Array.Accelerate.Pretty.Graphviz
        Data.Array.Accelerate.Pretty.Graphviz.Monad
        Data.Array.Accelerate.Pretty.Graphviz.Type
        Data.Array.Accelerate.Pretty.Print
        Data.Array.Accelerate.Trafo.Algebra
        Data.Array.Accelerate.Trafo.Base
        Data.Array.Accelerate.Trafo.Fusion
        Data.Array.Accelerate.Trafo.Rewrite
        Data.Array.Accelerate.Trafo.Sharing
        Data.Array.Accelerate.Trafo.Shrink
        Data.Array.Accelerate.Trafo.Simplify
        Data.Array.Accelerate.Trafo.Substitution
        -- Data.Array.Accelerate.Trafo.Vectorise

  hs-source-dirs:
        src

  c-sources:
        cbits/atomic.c
        cbits/flags.c
        cbits/monitoring.c

  if flag(debug) || flag(ekg)
    cc-options:         -DACCELERATE_DEBUG
    cpp-options:        -DACCELERATE_DEBUG

  if flag(ekg)
    cpp-options:        -DACCELERATE_MONITORING
    build-depends:
          async                         >= 2.0
        , ekg                           >= 0.1
        , ekg-core                      >= 0.1
        , text                          >= 1.0
        , time                          >= 1.4

  if flag(bounds-checks)
    cpp-options:        -DACCELERATE_BOUNDS_CHECKS

  if flag(unsafe-checks)
    cpp-options:        -DACCELERATE_UNSAFE_CHECKS

  if flag(internal-checks)
    cpp-options:        -DACCELERATE_INTERNAL_CHECKS

  if os(windows)
    cpp-options:        -DWIN32
    build-depends:      Win32
  else
    cpp-options:        -DUNIX
    build-depends:      unix

  ghc-options:          -O2 -Wall -funbox-strict-fields -fno-warn-name-shadowing
  ghc-prof-options:     -caf-all -auto-all

  if impl(ghc >= 7.0)
    ghc-options:        -fspec-constr-count=25

  if impl(ghc == 7.*)
    ghc-options:        -fcontext-stack=35

  if impl(ghc >= 8.0)
    ghc-options:        -freduction-depth=35

  if impl(ghc < 7.10)
    build-depends:
          th-lift-instances             >= 0.1

  -- Don't add the extensions list here. Instead, place individual LANGUAGE
  -- pragmas in the files that require a specific extension. This means the
  -- project loads in GHCi, and avoids extension clashes.
  --
  -- Extensions:


test-suite doctest
  type:                 exitcode-stdio-1.0
  hs-source-dirs:       test/doctest
  main-is:              Main.hs

  other-modules:
        Build_doctests

  build-depends:
          base                          >= 4.7
        , accelerate
        , doctest                       >= 0.11

  ghc-options:
        -Wall
        -threaded
        -rtsopts

  -- older ghc does not support the dimension-specialised show instances for
  -- arrays, which the doctests use
  if impl(ghc < 7.10)
    buildable:          False

  -- doctest only supports a single x-doctest-options line
  if impl(ghc == 7.*)
    x-doctest-options:  -fspec-constr-count=25 -fcontext-stack=35

  if impl(ghc >= 8.0)
    x-doctest-options:  -fspec-constr-count=25 -freduction-depth=35


source-repository head
  Type:                 git
  Location:             git://github.com/AccelerateHS/accelerate.git

source-repository this
  Type:                 git
  Tag:                  1.2.0.0
  Location:             git://github.com/AccelerateHS/accelerate.git

-- vim: nospell