Dynamic strictness control, including space leak repair

Seqaid : Space Leak Diagnostic and Remedial Tool

Andrew Seniuk rasfar@gmail.com 2014

The easiest way to get started with seqaid is

 cabal install seqaid
 seqaid demo

This will create a fresh directory, populate it with the test project, and configure, build and run it with seqaid instrumentation. Consult the leaky.cabal, README, and leaky.hs files in that directory for additional information. (The README explains the console output.)

To instrument your own project ("myapp" for didactic purposes), typically the following steps suffice:

1. cabal install seqaid, of course.

2. Add the following (at the appropriate level of indentation)
   to your myapp.cabal file:

     default-extensions:  TemplateHaskell
     ghc-options:         -fplugin=Seqaid.Plugin
     ghc-options:         -F -pgmF seqaidpp
     ghc-options:         -with-rtsopts=-T

3. Create a seqaid.config file in the project dir.
   The preprocessor will parse this, and control
   the extent of the instrumentation harness.

   There is no mechanism yet for real blanket
   instrumentation: You must name at least
   the modules you want instrumented, and the
   types you're interested in.  All binds in
   a module will be covered however.

   Looking at the seqaid.config file for leaky:

     package    leaky
     module     Main
       binds    duty
         types  Types.TA
     instances  Types.TA, Types.TB, Types.TC

   is this was changed to

     package    leaky
     module     Main
     types      Types.TA
     instances  Types.TA, Types.TB, Types.TC

   then all binds in module Main will be instrumented at
   all subexpressions having type Types.TA.

   The instances line names types you need to be able
   to force through.  If you get missing instance errors
   when you build, then you probably need to add those
   types to this list.

When the preprocessor runs, it will parse the configuration from seqaid.config, and perform the requisite insertions and substitutions behind the scenes.

NOTE: This will never ever edit your source files directly!
GHC takes care of running the preprocessor (-F option) on
its own temporary files, in the natural course of the
compilation pipeline.

The other project inseparable from this is .

More specific information resides in

And to a lesser extent, sporadic bits of information can also be found in files in the source distribution

  • the project README and .cabal files
  • comments in the source files [tend to obsolescence]

Subsequent versions will hopefully be more cohesive.

  • Installation

  • Dependencies (18)

  • Dependents (2)

    @hackage/acme-everything, @hackage/leaky
  • Package Flags

       (off by default)
      Note to those reading on Hackage:
      Please ignore these flags, which would be better presented in a collapsed state. The flags are mostly for development purposes.
       (off by default)

      (Still broken for GHC 7.10.) Until I learn how to test GHC version in the .cabal file, we need a flag, since some build-depends must be excluded completely. (CPP testing GLASGOW_HASKELL is then used the rest of the way, in the source files.)

       (off by default)


       (off by default)

      If we can prevent inlining of injected binds (without requiring user edits), that would probably be a good trade-off in terms of lost optimiser opportunities in exchange for assurance that the bind won't be inlined. This didn't work, and is a poor solution anyway.

       (off by default)

      Like NFDATAN_ONLY, but for newer Seqable module.

       (off by default)

      Actually this is just preparatory, haven't gone down this road far yet. (We would like a TH.Type to Type.Type conversion function in the GHC API. Then we'd just send the list of Type.Type for direct use by the Core-plugin downstream).

       (on by default)

      Rather than choose types to seqinj for based on the types of the top-level binds, use seqaidpp to parse the types from seqaid.config. This stays on perpetually, finally, and could be removed soon.

       (off by default)

      If True, then TH will be used as it has been, to blanket-inject all top-level functions (at least, those not explicitly or implicitly excluded). Now, if False, only RHS's with result types in the "types" list for the module (in seqaid.config) will be wrapped (again, at least those not explicitly or implicitly excluded).

       (on by default)

      This is the only working mode so far. (And it only works when tested on the "leaky" package.) The switch exists to exclude hashable/hashtables deps (and subdeps) from the first release, while I can continue to work on this aspect in the development head.

       (on by default)

      When set, seqaidDispatch emits status lines periodically.

       (off by default)

      If have to inject a class and instance anyway to evade DCE, no need for the old top-level seqinj_ declarations (we hope...). (But it turned out they were all still needed.)

       (off by default)

      To simplify debugging.

       (on by default)

      Include Typeable instance for (show . typeOf) in seqaidDispatch

       (on by default)

      The original intention was to make this a non-manual flag, to allow the build system to try cpphs first, and if that fails, then to try system-wide cpp (typically GNU). Due to path problems, when the build client installs cpphs in the course of installing, it turns out to be better to use a shell script to delegate which cpp runs, jimmy options, etc.