The ghc-make package

[Tags: bsd3, program]

The ghc-make program can be used as a drop-in replacement for ghc. This program targets two use cases:

See the readme for full details: https://github.com/ndmitchell/ghc-make#readme.


[Skip to ReadMe]

Properties

Versions0.1, 0.2, 0.2.1, 0.3, 0.3.1, 0.3.2
Change logCHANGES.txt
Dependenciesbase (==4.*), process (>=1.0), shake (>=0.14), unordered-containers (>=0.2.1) [details]
LicenseBSD3
CopyrightNeil Mitchell 2013-2015
AuthorNeil Mitchell <ndmitchell@gmail.com>
MaintainerNeil Mitchell <ndmitchell@gmail.com>
CategoryDevelopment
Home pagehttps://github.com/ndmitchell/ghc-make#readme
Bug trackerhttps://github.com/ndmitchell/ghc-make/issues
Source repositoryhead: git clone https://github.com/ndmitchell/ghc-make.git
Executablesghc-make
UploadedFri Feb 20 19:49:01 UTC 2015 by NeilMitchell
Downloads1209 total (82 in last 30 days)
Votes
0 []
StatusDocs not available [build log]
Last success reported on 2015-05-19 [all 2 reports]

Downloads

Maintainers' corner

For package maintainers and hackage trustees

Readme for ghc-make-0.3.2

ghc-make Hackage version Build Status

An alternative to ghc --make which supports parallel compilation of modules and runs faster when nothing needs compiling.

How do I use it?

Install ghc-make (cabal update && cabal install ghc-make). Then replace your calls to ghc my -arguments with ghc-make my -arguments. Almost all arguments and flags supported by ghc are supported by ghc-make - it is intended as a drop-in replacement.

What should I see?

Imagine you have a script that runs ghc --make MyCode && ./MyCode and that running ghc --make when nothing needs compiling takes 5 seconds (I have projects that take as long as 23 seconds). If you switch to ghc-make MyCode && ./MyCode then when nothing needs compiling it will take almost no time (less than 0.2 seconds). If things need compiling it will take the compilation time plus the time with ghc --make when nothing needs compiling (in this example, 5 seconds extra). If the source changes on less than half the executions you will see a speedup.

The ghc-make program produces a handful of metadata files which are stored with the .ghc-make prefix. These files will be placed in the current directory, or the -hidir/-odir directory if specified.

How do I turn on parallel module compilation?

Pass -j4 to build using 4 cores. In my experience you usually need a parallel factor of 3x to match ghc --make on a single core, since ghc --make does a lot of caching that is unavailable to ghc-make.

To use ghc-make with Cabal, try cabal build --with-ghc=ghc-make --ghc-options=-j4. (This technique is due to the ghc-parmake project, which also does parallel ghc --make compiles.)

What GHC features are unsupported?

Anything not captured by ghc -M will not be tracked, including dependencies registered by Template Haskell and #include files.

Why is it faster?

When GHC does a compilation check it runs any preprocessors and parses the Haskell files, which can be slow. When ghc-make does a compilation check it reads a list of file names and modification times from a database and checks the times still match, and if they do, it does nothing.

Why is it slower?

When things have changed ghc-make also runs ghc-pkg list and ghc -M to get a list of dependencies. To produce that list, GHC has to run any preprocessors and parse the Haskell files. If GHC was able to produce the dependencies while building (as gcc is able to do) then ghc-make would never be noticeably slower.

How is it implemented?

This program uses the Shake library for dependency tracking and ghc --make for building.

To pass options to the underlying Shake build system prefix them with --shake, for example --shake--report=- will write a profile report to stdout and --shake--help will list the available Shake options.

Should GHC just use Shake directly?

Should large and important project use authors pet library? Yes, of course :smiley:. If ghc --make used Shake it is likely their builds with no recompilation would be just as fast as ghc-make, and they could take advantage of parallel compilation with no additional overhead. However, integrating Shake into such a large code base would be a lot of work - perhaps you should offer to help the GHC team?