parallel-io.cabal

Name:               parallel-io
Version:            0.3.4
Cabal-Version:      >= 1.10
Category:           Concurrency
Synopsis:           Combinators for executing IO actions in parallel on a thread pool.
Description:        This package provides combinators for sequencing IO actions onto a thread pool. The
                    thread pool is guaranteed to contain no more unblocked threads than a user-specified upper limit, thus
                    minimizing contention.
                    .
                    Furthermore, the parallel combinators can be used reentrantly - your parallel
                    actions can spawn more parallel actions - without violating this property of the thread pool.
                    .
                    The package is inspired by the thread <http://thread.gmane.org/gmane.comp.lang.haskell.cafe/56499/focus=56521>.
                    Thanks to Neil Mitchell and Bulat Ziganshin for some of the code this package is based on.
License:            BSD3
License-File:       LICENSE
Homepage:           http://batterseapower.github.com/parallel-io
Author:             Max Bolingbroke <batterseapower@hotmail.com>,
                    Neil Mitchell <ndmitchell@gmail.com>,
                    Bulat Ziganshin <bulat.ziganshin@gmail.com>
Maintainer:         Max Bolingbroke <batterseapower@hotmail.com>
Build-Type:         Simple


Flag Benchmark
    Description:    Build the benchmarking tool
    Default:        False

Flag Fuzz
    Description:    Build the fuzzing tool for discovering deadlocks
    Default:        False

Flag Tests
    Description:    Build the test runner
    Default:        False

Library
    Default-Language: Haskell98
    Exposed-Modules:
        Control.Concurrent.ParallelIO
        Control.Concurrent.ParallelIO.Global
        Control.Concurrent.ParallelIO.Local
    Other-Modules:    
        Control.Concurrent.ParallelIO.Compat
    
    Build-Depends:  base >= 4 && < 5, extensible-exceptions > 0.1.0.1, containers >= 0.2 && < 0.6, random >= 1.0 && < 1.3

Executable benchmark
    Default-Language: Haskell98
    Main-Is:        Control/Concurrent/ParallelIO/Benchmark.hs
    
    if !flag(benchmark)
        Buildable:  False
    else
        Build-Depends:  base >= 4 && < 5, extensible-exceptions > 0.1.0.1, containers >= 0.2 && < 0.6, random >= 1.0 && < 1.3,
                        time >= 1
    
        Ghc-Options:    -threaded

Executable tests
    Default-Language: Haskell98
    Main-Is:        Control/Concurrent/ParallelIO/Tests.hs
    
    if !flag(tests)
        Buildable:  False
    else
        Build-Depends:  base >= 4 && < 5, extensible-exceptions > 0.1.0.1, containers >= 0.2 && < 0.6, random >= 1.0 && < 1.3,
                        test-framework >= 0.1.1, test-framework-hunit >= 0.1.1, HUnit >= 1.2 && < 2
    
        Ghc-Options:    -threaded -rtsopts

Executable fuzz
    Default-Language: Haskell98
    Main-Is:        Control/Concurrent/ParallelIO/Fuzz.hs

    if !flag(fuzz)
        Buildable:  False
    else
        Build-Depends:  base >= 4 && < 5, extensible-exceptions > 0.1.0.1, containers >= 0.2 && < 0.6, random >= 1.0 && < 1.3

        Ghc-Options:    -threaded -rtsopts

Executable fuzz-seq
    Default-Language: Haskell98
    Main-Is:        Control/Concurrent/ParallelIO/Fuzz.hs

    if !flag(fuzz)
        Buildable:  False
    else
        Build-Depends:  base >= 4 && < 5, extensible-exceptions > 0.1.0.1, containers >= 0.2 && < 0.6, random >= 1.0 && < 1.3