15916b269096371862728bbebd1e80398ee7bea0
[ghc.git] / docs / users_guide / using-optimisation.rst
1 .. _options-optimise:
2
3 Optimisation (code improvement)
4 -------------------------------
5
6 .. index::
7    single: optimisation
8    single: improvement, code
9
10 The ``-O*`` options specify convenient "packages" of optimisation flags;
11 the ``-f*`` options described later on specify *individual*
12 optimisations to be turned on/off; the ``-m*`` options specify
13 *machine-specific* optimisations to be turned on/off.
14
15 Most of these options are boolean and have options to turn them both "on" and
16 "off" (beginning with the prefix ``no-``). For instance, while ``-fspecialise``
17 enables specialisation, ``-fno-specialise`` disables it. When multiple flags for
18 the same option appear in the command-line they are evaluated from left to
19 right. For instance, ``-fno-specialise -fspecialise`` will enable
20 specialisation.
21
22 It is important to note that the ``-O*`` flags are roughly equivalent to
23 combinations of ``-f*`` flags. For this reason, the effect of the
24 ``-O*`` and ``-f*`` flags is dependent upon the order in which they
25 occur on the command line.
26
27 For instance, take the example of ``-fno-specialise -O1``. Despite the
28 ``-fno-specialise`` appearing in the command line, specialisation will
29 still be enabled. This is the case as ``-O1`` implies ``-fspecialise``,
30 overriding the previous flag. By contrast, ``-O1 -fno-specialise`` will
31 compile without specialisation, as one would expect.
32
33 .. _optimise-pkgs:
34
35 ``-O*``: convenient “packages” of optimisation flags.
36 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
37
38 There are *many* options that affect the quality of code produced by
39 GHC. Most people only have a general goal, something like "Compile
40 quickly" or "Make my program run like greased lightning." The following
41 "packages" of optimisations (or lack thereof) should suffice.
42
43 Note that higher optimisation levels cause more cross-module
44 optimisation to be performed, which can have an impact on how much of
45 your program needs to be recompiled when you change something. This is
46 one reason to stick to no-optimisation when developing code.
47
48 **No ``-O*``-type option specified:** This is taken to mean “Please 
49 compile quickly; I'm not over-bothered about compiled-code quality.”
50 So, for example, ``ghc -c Foo.hs``
51
52 .. ghc-flag:: -O0
53
54     Means "turn off all optimisation", reverting to the same settings as
55     if no ``-O`` options had been specified. Saying ``-O0`` can be
56     useful if e.g. ``make`` has inserted a ``-O`` on the command line
57     already.
58
59 .. ghc-flag:: -O
60               -O1
61
62     .. index::
63        single: optimise; normally
64
65     Means: "Generate good-quality code without taking too long about
66     it." Thus, for example: ``ghc -c -O Main.lhs``
67
68 .. ghc-flag:: -O2
69
70     .. index::
71        single: optimise; aggressively
72
73     Means: "Apply every non-dangerous optimisation, even if it means
74     significantly longer compile times."
75
76     The avoided "dangerous" optimisations are those that can make
77     runtime or space *worse* if you're unlucky. They are normally turned
78     on or off individually.
79
80 .. ghc-flag:: -Odph
81
82     .. index::
83        single: optimise; DPH
84
85     Enables all ``-O2`` optimisation, sets
86     ``-fmax-simplifier-iterations=20`` and ``-fsimplifier-phases=3``.
87     Designed for use with :ref:`Data Parallel Haskell (DPH) <dph>`.
88
89 We don't use a ``-O*`` flag for day-to-day work. We use ``-O`` to get
90 respectable speed; e.g., when we want to measure something. When we want
91 to go for broke, we tend to use ``-O2`` (and we go for lots of coffee
92 breaks).
93
94 The easiest way to see what ``-O`` (etc.) “really mean” is to run with
95 :ghc-flag:`-v`, then stand back in amazement.
96
97 .. _options-f:
98
99 ``-f*``: platform-independent flags
100 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
101
102 .. index::
103    single: -f\* options (GHC)
104    single: -fno-\* options (GHC)
105
106 These flags turn on and off individual optimisations. Flags marked as
107 on by default are enabled by ``-O``, and as such you shouldn't
108 need to set any of them explicitly. A flag ``-fwombat`` can be negated
109 by saying ``-fno-wombat``.
110
111 .. ghc-flag:: -fcase-merge
112
113     :default: on
114
115     Merge immediately-nested case expressions that scrutinise the same variable.
116     For example, ::
117
118           case x of
119              Red -> e1
120              _   -> case x of
121                       Blue -> e2
122                       Green -> e3
123
124     Is transformed to, ::
125
126           case x of
127              Red -> e1
128              Blue -> e2
129              Green -> e2
130
131 .. ghc-flag:: -fcase-folding
132
133     :default: on
134
135     Allow constant folding in case expressions that scrutinise some primops:
136     For example, ::
137
138           case x `minusWord#` 10## of
139              10## -> e1
140              20## -> e2
141              v    -> e3
142
143     Is transformed to, ::
144
145           case x of
146              20## -> e1
147              30## -> e2
148              _    -> let v = x `minusWord#` 10## in e3
149
150 .. ghc-flag:: -fcall-arity
151
152     :default: on
153
154     Enable call-arity analysis.
155
156 .. ghc-flag:: -fcmm-elim-common-blocks
157
158     :default: on
159
160     Enables the common block elimination optimisation
161     in the code generator. This optimisation attempts to find identical
162     Cmm blocks and eliminate the duplicates.
163
164 .. ghc-flag:: -fcmm-sink
165
166     :default: on
167
168     Enables the sinking pass in the code generator.
169     This optimisation attempts to find identical Cmm blocks and
170     eliminate the duplicates attempts to move variable bindings closer
171     to their usage sites. It also inlines simple expressions like
172     literals or registers.
173
174 .. ghc-flag:: -fcpr-anal
175
176     :default: on
177
178     Turn on CPR analysis in the demand analyser.
179
180 .. ghc-flag:: -fcse
181
182     :default: on
183
184     Enables the common-sub-expression elimination
185     optimisation. Switching this off can be useful if you have some
186     ``unsafePerformIO`` expressions that you don't want commoned-up.
187
188 .. ghc-flag:: -fstg-cse
189
190     :default: on
191
192     Enables the common-sub-expression elimination optimisation on the STG
193     intermediate language, where it is able to common up some subexpressions
194     that differ in their types, but not their represetation.
195
196 .. ghc-flag:: -fdicts-cheap
197
198     :default: off
199
200     A very experimental flag that makes dictionary-valued expressions
201     seem cheap to the optimiser.
202
203 .. ghc-flag:: -fdicts-strict
204
205     :default: off
206
207     Make dictionaries strict.
208
209 .. ghc-flag:: -fdmd-tx-dict-sel
210
211     :default: on
212
213     Use a special demand transformer for dictionary selectors.
214
215 .. ghc-flag:: -fdo-eta-reduction
216
217     :default: on
218
219     Eta-reduce lambda expressions, if doing so gets rid of a whole group of
220     lambdas.
221
222 .. ghc-flag:: -fdo-lambda-eta-expansion
223
224     :default: on
225
226     Eta-expand let-bindings to increase their arity.
227
228 .. ghc-flag:: -feager-blackholing
229
230     :default: off
231
232     Usually GHC black-holes a thunk only when it switches threads. This
233     flag makes it do so as soon as the thunk is entered. See `Haskell on
234     a shared-memory
235     multiprocessor <http://community.haskell.org/~simonmar/papers/multiproc.pdf>`__.
236
237 .. ghc-flag:: -fexcess-precision
238
239     :default: off
240
241     When this option is given, intermediate floating point values can
242     have a *greater* precision/range than the final type. Generally this
243     is a good thing, but some programs may rely on the exact
244     precision/range of ``Float``/``Double`` values and should not use
245     this option for their compilation.
246
247     Note that the 32-bit x86 native code generator only supports
248     excess-precision mode, so neither ``-fexcess-precision`` nor
249     ``-fno-excess-precision`` has any effect. This is a known bug, see
250     :ref:`bugs-ghc`.
251
252 .. ghc-flag:: -fexpose-all-unfoldings
253
254     :default: off
255
256     An experimental flag to expose all unfoldings, even for very large
257     or recursive functions. This allows for all functions to be inlined
258     while usually GHC would avoid inlining larger functions.
259
260 .. ghc-flag:: -ffloat-in
261
262     :default: on
263
264     Float let-bindings inwards, nearer their binding
265     site. See `Let-floating: moving bindings to give faster programs
266     (ICFP'96) <http://research.microsoft.com/en-us/um/people/simonpj/papers/float.ps.gz>`__.
267
268     This optimisation moves let bindings closer to their use site. The
269     benefit here is that this may avoid unnecessary allocation if the
270     branch the let is now on is never executed. It also enables other
271     optimisation passes to work more effectively as they have more
272     information locally.
273
274     This optimisation isn't always beneficial though (so GHC applies
275     some heuristics to decide when to apply it). The details get
276     complicated but a simple example is that it is often beneficial to
277     move let bindings outwards so that multiple let bindings can be
278     grouped into a larger single let binding, effectively batching their
279     allocation and helping the garbage collector and allocator.
280
281 .. ghc-flag:: -ffull-laziness
282
283     :default: on
284
285     Run the full laziness optimisation (also known as
286     let-floating), which floats let-bindings outside enclosing lambdas,
287     in the hope they will be thereby be computed less often. See
288     `Let-floating: moving bindings to give faster programs
289     (ICFP'96) <http://research.microsoft.com/en-us/um/people/simonpj/papers/float.ps.gz>`__.
290     Full laziness increases sharing, which can lead to increased memory
291     residency.
292
293     .. note::
294        GHC doesn't implement complete full-laziness. When
295        optimisation in on, and ``-fno-full-laziness`` is not given, some
296        transformations that increase sharing are performed, such as
297        extracting repeated computations from a loop. These are the same
298        transformations that a fully lazy implementation would do, the
299        difference is that GHC doesn't consistently apply full-laziness, so
300        don't rely on it.
301
302 .. ghc-flag:: -ffun-to-thunk
303
304     :default: off
305
306     Worker-wrapper removes unused arguments, but usually we do not
307     remove them all, lest it turn a function closure into a thunk,
308     thereby perhaps creating a space leak and/or disrupting inlining.
309     This flag allows worker/wrapper to remove *all* value lambdas.
310
311 .. ghc-flag:: -fignore-asserts
312
313     :default: on
314
315     Causes GHC to ignore uses of the function ``Exception.assert`` in source
316     code (in other words, rewriting ``Exception.assert p e`` to ``e`` (see
317     :ref:`assertions`).
318
319 .. ghc-flag:: -fignore-interface-pragmas
320
321     :default: off
322
323     Tells GHC to ignore all inessential information when reading
324     interface files. That is, even if :file:`M.hi` contains unfolding or
325     strictness information for a function, GHC will ignore that
326     information.
327
328 .. ghc-flag:: -flate-dmd-anal
329
330     :default: off
331
332     Run demand analysis again, at the end of the simplification
333     pipeline. We found some opportunities for discovering strictness
334     that were not visible earlier; and optimisations like
335     :ghc-flag:`-fspec-constr` can create functions with unused arguments which
336     are eliminated by late demand analysis. Improvements are modest, but
337     so is the cost. See notes on the :ghc-wiki:`Trac wiki page <LateDmd>`.
338
339 .. ghc-flag:: -fliberate-case
340
341     :default: off but enabled with :ghc-flag:`-O2`.
342
343     Turn on the liberate-case transformation. This unrolls recursive function
344     once in its own RHS, to avoid repeated case analysis of free variables. It's
345     a bit like the call-pattern specialiser (:ghc-flag:`-fspec-constr`) but for
346     free variables rather than arguments.
347
348 .. ghc-flag:: -fliberate-case-threshold=⟨n⟩
349
350     :default: 2000
351
352     Set the size threshold for the liberate-case transformation.
353
354 .. ghc-flag:: -floopification
355
356     :default: on
357
358     When this optimisation is enabled the code generator will turn all
359     self-recursive saturated tail calls into local jumps rather than
360     function calls.
361
362 .. ghc-flag:: -fmax-inline-alloc-size=⟨n⟩
363
364     :default: 128
365
366     Set the maximum size of inline array allocations to n bytes.
367     GHC will allocate non-pinned arrays of statically known size in the current
368     nursery block if they're no bigger than n bytes, ignoring GC overheap. This
369     value should be quite a bit smaller than the block size (typically: 4096).
370
371 .. ghc-flag:: -fmax-inline-memcpy-insns=⟨n⟩
372
373     :default: 32
374
375     Inline ``memcpy`` calls if they would generate no more than ⟨n⟩ pseudo-instructions.
376
377 .. ghc-flag:: -fmax-inline-memset-insns=⟨n⟩
378
379     :default: 32
380
381     Inline ``memset`` calls if they would generate no more than n pseudo
382     instructions.
383
384 .. ghc-flag:: -fmax-relevant-binds=⟨n⟩
385               -fno-max-relevant-bindings
386
387     :default: 6
388
389     The type checker sometimes displays a fragment of the type
390     environment in error messages, but only up to some maximum number,
391     set by this flag. Turning it off with
392     ``-fno-max-relevant-bindings`` gives an unlimited number.
393     Syntactically top-level bindings are also usually excluded (since
394     they may be numerous), but ``-fno-max-relevant-bindings`` includes
395     them too.
396
397 .. ghc-flag:: -fmax-valid-substitutions=⟨n⟩
398               -fno-max-valid-substitutions
399
400     :default: 6
401
402     The type checker sometimes displays a list of valid substitutions
403     for typed holes in error messages, but only up to some maximum number,
404     set by this flag. Turning it off with
405     ``-fno-max-valid-substitutions`` gives an unlimited number.
406
407 .. ghc-flag:: -fmax-uncovered-patterns=⟨n⟩
408
409     :default: 4
410
411     Maximum number of unmatched patterns to be shown in warnings generated by
412     :ghc-flag:`-Wincomplete-patterns` and :ghc-flag:`-Wincomplete-uni-patterns`.
413
414 .. ghc-flag:: -fmax-simplifier-iterations=⟨n⟩
415
416     :default: 4
417
418     Sets the maximal number of iterations for the simplifier.
419
420 .. ghc-flag:: -fmax-worker-args=⟨n⟩
421
422     :default: 10
423
424     If a worker has that many arguments, none will be unpacked anymore.
425
426 .. ghc-flag:: -fno-opt-coercion
427
428     :default: off
429
430     Turn off the coercion optimiser.
431
432 .. ghc-flag:: -fno-pre-inlining
433
434     :default: off
435
436     Turn off pre-inlining.
437
438 .. ghc-flag:: -fno-state-hack
439
440     :default: off
441
442     Turn off the "state hack" whereby any lambda with a ``State#`` token
443     as argument is considered to be single-entry, hence it is considered
444     okay to inline things inside it. This can improve performance of IO
445     and ST monad code, but it runs the risk of reducing sharing.
446
447 .. ghc-flag:: -fomit-interface-pragmas
448
449     :default: off
450
451     Tells GHC to omit all inessential information from the interface
452     file generated for the module being compiled (say M). This means
453     that a module importing M will see only the *types* of the functions
454     that M exports, but not their unfoldings, strictness info, etc.
455     Hence, for example, no function exported by M will be inlined into
456     an importing module. The benefit is that modules that import M will
457     need to be recompiled less often (only when M's exports change their
458     type, not when they change their implementation).
459
460 .. ghc-flag:: -fomit-yields
461
462     :default: on
463
464     Tells GHC to omit heap checks when no allocation is
465     being performed. While this improves binary sizes by about 5%, it
466     also means that threads run in tight non-allocating loops will not
467     get preempted in a timely fashion. If it is important to always be
468     able to interrupt such threads, you should turn this optimization
469     off. Consider also recompiling all libraries with this optimization
470     turned off, if you need to guarantee interruptibility.
471
472 .. ghc-flag:: -fpedantic-bottoms
473
474     Make GHC be more precise about its treatment of bottom (but see also
475     :ghc-flag:`-fno-state-hack`). In particular, stop GHC eta-expanding through
476     a case expression, which is good for performance, but bad if you are
477     using ``seq`` on partial applications.
478
479 .. ghc-flag:: -fregs-graph
480
481     :default: off due to a performance regression bug (:ghc-ticket:`7679`)
482
483     *Only applies in combination with the native code generator.* Use the graph
484     colouring register allocator for register allocation in the native code
485     generator. By default, GHC uses a simpler, faster linear register allocator.
486     The downside being that the linear register allocator usually generates
487     worse code.
488
489     Note that the graph colouring allocator is a bit experimental and may fail
490     when faced with code with high register pressure :ghc-ticket:`8657`.
491
492 .. ghc-flag:: -fregs-iterative
493
494     :default: off
495
496     *Only applies in combination with the native code generator.* Use the
497     iterative coalescing graph colouring register allocator for register
498     allocation in the native code generator. This is the same register allocator
499     as the :ghc-flag:`-fregs-graph` one but also enables iterative coalescing
500     during register allocation.
501
502 .. ghc-flag:: -fsimplifier-phases=⟨n⟩
503
504     :default: 2
505
506     Set the number of phases for the simplifier. Ignored with ``-O0``.
507
508 .. ghc-flag:: -fsimpl-tick-factor=⟨n⟩
509
510     :default: 100
511
512     GHC's optimiser can diverge if you write rewrite rules
513     (:ref:`rewrite-rules`) that don't terminate, or (less satisfactorily)
514     if you code up recursion through data types (:ref:`bugs-ghc`). To
515     avoid making the compiler fall into an infinite loop, the optimiser
516     carries a "tick count" and stops inlining and applying rewrite rules
517     when this count is exceeded. The limit is set as a multiple of the
518     program size, so bigger programs get more ticks. The
519     ``-fsimpl-tick-factor`` flag lets you change the multiplier. The
520     default is 100; numbers larger than 100 give more ticks, and numbers
521     smaller than 100 give fewer.
522
523     If the tick-count expires, GHC summarises what simplifier steps it
524     has done; you can use ``-fddump-simpl-stats`` to generate a much
525     more detailed list. Usually that identifies the loop quite
526     accurately, because some numbers are very large.
527
528 .. ghc-flag:: -fspec-constr
529
530     :default: off but enabled by :ghc-flag:`-O2`.
531
532     Turn on call-pattern specialisation; see `Call-pattern specialisation for
533     Haskell programs
534     <https://www.microsoft.com/en-us/research/publication/system-f-with-type-equality-coercions-2/>`__.
535
536     This optimisation specializes recursive functions according to their
537     argument "shapes". This is best explained by example so consider: ::
538
539         last :: [a] -> a
540         last [] = error "last"
541         last (x : []) = x
542         last (x : xs) = last xs
543
544     In this code, once we pass the initial check for an empty list we
545     know that in the recursive case this pattern match is redundant. As
546     such ``-fspec-constr`` will transform the above code to: ::
547
548         last :: [a] -> a
549         last []       = error "last"
550         last (x : xs) = last' x xs
551             where
552               last' x []       = x
553               last' x (y : ys) = last' y ys
554
555     As well avoid unnecessary pattern matching it also helps avoid
556     unnecessary allocation. This applies when a argument is strict in
557     the recursive call to itself but not on the initial entry. As strict
558     recursive branch of the function is created similar to the above
559     example.
560
561     It is also possible for library writers to instruct GHC to perform
562     call-pattern specialisation extremely aggressively. This is
563     necessary for some highly optimized libraries, where we may want to
564     specialize regardless of the number of specialisations, or the size
565     of the code. As an example, consider a simplified use-case from the
566     ``vector`` library: ::
567
568         import GHC.Types (SPEC(..))
569
570         foldl :: (a -> b -> a) -> a -> Stream b -> a
571         {-# INLINE foldl #-}
572         foldl f z (Stream step s _) = foldl_loop SPEC z s
573           where
574             foldl_loop !sPEC z s = case step s of
575                                     Yield x s' -> foldl_loop sPEC (f z x) s'
576                                     Skip       -> foldl_loop sPEC z s'
577                                     Done       -> z
578
579     Here, after GHC inlines the body of ``foldl`` to a call site, it
580     will perform call-pattern specialisation very aggressively on
581     ``foldl_loop`` due to the use of ``SPEC`` in the argument of the
582     loop body. ``SPEC`` from ``GHC.Types`` is specifically recognised by
583     the compiler.
584
585     (NB: it is extremely important you use ``seq`` or a bang pattern on
586     the ``SPEC`` argument!)
587
588     In particular, after inlining this will expose ``f`` to the loop
589     body directly, allowing heavy specialisation over the recursive
590     cases.
591
592 .. ghc-flag:: -fspec-constr-keen
593
594     :default: off
595
596     If this flag is on, call-pattern specialisation will specialise a call
597     ``(f (Just x))`` with an explicit constructor argument, even if the argument
598     is not scrutinised in the body of the function. This is sometimes
599     beneficial; e.g. the argument might be given to some other function
600     that can itself be specialised.
601
602 .. ghc-flag:: -fspec-constr-count=⟨n⟩
603
604     :default: 3
605
606     Set the maximum number of specialisations that will be created for
607     any one function by the SpecConstr transformation.
608
609 .. ghc-flag:: -fspec-constr-threshold=⟨n⟩
610
611     :default: 2000
612
613     Set the size threshold for the SpecConstr transformation.
614
615 .. ghc-flag:: -fspecialise
616
617     :default: on
618
619     Specialise each type-class-overloaded function
620     defined in this module for the types at which it is called in this
621     module. If :ghc-flag:`-fcross-module-specialise` is set imported functions
622     that have an INLINABLE pragma (:ref:`inlinable-pragma`) will be
623     specialised as well.
624
625 .. ghc-flag:: -fspecialise-aggressively
626
627     :default: off
628
629     By default only type class methods and methods marked ``INLINABLE`` or
630     ``INLINE`` are specialised. This flag will specialise any overloaded function
631     regardless of size if its unfolding is available. This flag is not
632     included in any optimisation level as it can massively increase code
633     size. It can be used in conjunction with :ghc-flag:`-fexpose-all-unfoldings`
634     if you want to ensure all calls are specialised.
635
636
637 .. ghc-flag:: -fcross-module-specialise
638
639     :default: on
640
641     Specialise ``INLINABLE`` (:ref:`inlinable-pragma`)
642     type-class-overloaded functions imported from other modules for the types at
643     which they are called in this module. Note that specialisation must be
644     enabled (by ``-fspecialise``) for this to have any effect.
645
646 .. ghc-flag:: -fsolve-constant-dicts
647
648     :default: on
649
650     When solving constraints, try to eagerly solve
651     super classes using available dictionaries.
652
653     For example::
654
655       class M a b where m :: a -> b
656
657       type C a b = (Num a, M a b)
658
659       f :: C Int b => b -> Int -> Int
660       f _ x = x + 1
661
662     The body of `f` requires a `Num Int` instance. We could solve this
663     constraint from the context  because we have `C Int b` and that provides us
664     a
665     solution for `Num Int`. However, we can often produce much better code
666     by directly solving for an available `Num Int` dictionary we might have at
667     hand. This removes potentially many layers of indirection and crucially
668     allows other optimisations to fire as the dictionary will be statically
669     known and selector functions can be inlined.
670
671     The optimisation also works for GADTs which bind dictionaries. If we
672     statically know which class dictionary we need then we will solve it
673     directly rather than indirectly using the one passed in at run time.
674
675
676
677 .. ghc-flag:: -fstatic-argument-transformation
678
679     :default: off
680
681     Turn on the static argument transformation, which turns a recursive
682     function into a non-recursive one with a local recursive loop. See
683     Chapter 7 of `Andre Santos's PhD
684     thesis <http://research.microsoft.com/en-us/um/people/simonpj/papers/santos-thesis.ps.gz>`__
685
686 .. ghc-flag:: -fstrictness
687
688     :default: on
689
690     Switch on the strictness analyser. The
691     implementation is described in the paper `Theory and Practice of Demand Analysis in Haskell`<https://www.microsoft.com/en-us/research/wp-content/uploads/2017/03/demand-jfp-draft.pdf>`__.
692
693     The strictness analyser figures out when arguments and variables in
694     a function can be treated 'strictly' (that is they are always
695     evaluated in the function at some point). This allow GHC to apply
696     certain optimisations such as unboxing that otherwise don't apply as
697     they change the semantics of the program when applied to lazy
698     arguments.
699
700 .. ghc-flag:: -fstrictness-before=⟨n⟩
701
702     Run an additional strictness analysis before simplifier phase ⟨n⟩.
703
704 .. ghc-flag:: -funbox-small-strict-fields
705
706     :default: on
707
708     .. index::
709        single: strict constructor fields
710        single: constructor fields, strict
711
712     This option causes all constructor fields which
713     are marked strict (i.e. “!”) and which representation is smaller or
714     equal to the size of a pointer to be unpacked, if possible. It is
715     equivalent to adding an ``UNPACK`` pragma (see :ref:`unpack-pragma`)
716     to every strict constructor field that fulfils the size restriction.
717
718     For example, the constructor fields in the following data types ::
719
720         data A = A !Int
721         data B = B !A
722         newtype C = C B
723         data D = D !C
724
725     would all be represented by a single ``Int#`` (see
726     :ref:`primitives`) value with ``-funbox-small-strict-fields``
727     enabled.
728
729     This option is less of a sledgehammer than
730     ``-funbox-strict-fields``: it should rarely make things worse. If
731     you use ``-funbox-small-strict-fields`` to turn on unboxing by
732     default you can disable it for certain constructor fields using the
733     ``NOUNPACK`` pragma (see :ref:`nounpack-pragma`).
734
735     Note that for consistency ``Double``, ``Word64``, and ``Int64``
736     constructor fields are unpacked on 32-bit platforms, even though
737     they are technically larger than a pointer on those platforms.
738
739 .. ghc-flag:: -funbox-strict-fields
740
741     :default: off
742
743     .. index::
744        single: strict constructor fields
745        single: constructor fields, strict
746
747     This option causes all constructor fields which are marked strict
748     (i.e. ``!``) to be unpacked if possible. It is equivalent to adding an
749     ``UNPACK`` pragma to every strict constructor field (see
750     :ref:`unpack-pragma`).
751
752     This option is a bit of a sledgehammer: it might sometimes make
753     things worse. Selectively unboxing fields by using ``UNPACK``
754     pragmas might be better. An alternative is to use
755     ``-funbox-strict-fields`` to turn on unboxing by default but disable
756     it for certain constructor fields using the ``NOUNPACK`` pragma (see
757     :ref:`nounpack-pragma`).
758
759     Alternatively you can use :ghc-flag:`-funbox-small-strict-fields` to only
760     unbox strict fields which are "small".
761
762 .. ghc-flag:: -funfolding-creation-threshold=⟨n⟩
763
764     :default: 750
765
766     .. index::
767        single: inlining, controlling
768        single: unfolding, controlling
769
770     Governs the maximum size that GHC will allow a
771     function unfolding to be. (An unfolding has a “size” that reflects
772     the cost in terms of “code bloat” of expanding (aka inlining) that
773     unfolding at a call site. A bigger function would be assigned a
774     bigger cost.)
775
776     Consequences:
777
778     a. nothing larger than this will be inlined (unless it has an ``INLINE`` pragma)
779     b. nothing larger than this will be spewed into an interface file.
780
781     Increasing this figure is more likely to result in longer compile times
782     than faster code. The :ghc-flag:`-funfolding-use-threshold=⟨n⟩` is more
783     useful.
784
785 .. ghc-flag:: -funfolding-dict-discount=⟨n⟩
786
787     :default: 30
788
789     .. index::
790        single: inlining, controlling
791        single: unfolding, controlling
792
793     How eager should the compiler be to inline dictionaries?
794
795 .. ghc-flag:: -funfolding-fun-discount=⟨n⟩
796
797     :default: 60
798
799     .. index::
800        single: inlining, controlling
801        single: unfolding, controlling
802
803     How eager should the compiler be to inline functions?
804
805 .. ghc-flag:: -funfolding-keeness-factor=⟨n⟩
806
807     :default: 1.5
808
809     .. index::
810        single: inlining, controlling
811        single: unfolding, controlling
812
813     How eager should the compiler be to inline functions?
814
815 .. ghc-flag:: -funfolding-use-threshold=⟨n⟩
816
817     :default: 60
818
819     .. index::
820        single: inlining, controlling
821        single: unfolding, controlling
822
823     This is the magic cut-off figure for unfolding (aka
824     inlining): below this size, a function definition will be unfolded
825     at the call-site, any bigger and it won't. The size computed for a
826     function depends on two things: the actual size of the expression
827     minus any discounts that apply depending on the context into which
828     the expression is to be inlined.
829
830     The difference between this and
831     :ghc-flag:`-funfolding-creation-threshold=⟨n⟩` is that this one determines
832     if a function definition will be inlined *at a call site*. The other option
833     determines if a function definition will be kept around at all for
834     potential inlining.
835
836 .. ghc-flag:: -fvectorisation-avoidance
837
838     :default: on
839
840     .. index::
841        single: -fvectorisation-avoidance
842
843     Part of :ref:`Data Parallel Haskell (DPH) <dph>`.
844
845     Enable the *vectorisation* avoidance optimisation.
846     This optimisation only works when used in combination with the
847     ``-fvectorise`` transformation.
848
849     While vectorisation of code using DPH is often a big win, it can
850     also produce worse results for some kinds of code. This optimisation
851     modifies the vectorisation transformation to try to determine if a
852     function would be better of unvectorised and if so, do just that.
853
854 .. ghc-flag:: -fvectorise
855
856     :default: off
857
858     Part of :ref:`Data Parallel Haskell (DPH) <dph>`.
859
860     Enable the *vectorisation* optimisation
861     transformation. This optimisation transforms the nested data
862     parallelism code of programs using DPH into flat data parallelism.
863     Flat data parallel programs should have better load balancing,
864     enable SIMD parallelism and friendlier cache behaviour.