Example plugin

[angerman]

This is an example use case for the Extensible Interface Files, ghc!2948 GHC extension. The idea is to use store and load GHCs core representation from the interface files without having to resort to -fexpose-all-unfoldings or excessive INLINE pragmas. A high level overview is given in README.

Example.hs is the plugin code to be used with GHC, and which contains all the logic to write out, as well as read in the core expressions and inline them.

The setup consists of a Lib module, and a Main module, where the Main module depends on the Lib module. Thus compiling the Main module with the Example plugin should demonstrate the inlining of core expressions.

NOTE: There is also a Makefile that ties this all together and provides a reproducible setup.

Discussion

The Main module contains the following function t:

tools/examples/extensible-interface-files/core-plugins/basic-example/Main.hs

Lines 19 to 20 in 23c7b7c

	t :: Int -> Int -> Bool
	t a b = g (f a + b)

which we call in the main function of the Main module here:

tools/examples/extensible-interface-files/core-plugins/basic-example/Main.hs

Lines 6 to 9 in 23c7b7c

	main = do
	-- Simpler examples
	print (t x y)

Thus to evaluate t we need f, g as well as x and y, from the Lib module.

tools/examples/extensible-interface-files/core-plugins/basic-example/Lib.hs

Lines 21 to 23 in 23c7b7c

	x, y :: Int
	x = 1
	y = x + 2

tools/examples/extensible-interface-files/core-plugins/basic-example/Lib.hs

Lines 25 to 28 in 23c7b7c

	f :: Int -> Int
	f = plus 1
	where
	plus = (+)

tools/examples/extensible-interface-files/core-plugins/basic-example/Lib.hs

Lines 35 to 37 in 23c7b7c

	g :: Int -> Bool
	g 0 = True
	g _ = False

(1) Without using the plugin we can see that the Main module produces the following core:

 main :: IO ()
 [LclIdX,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
          WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 570 0}]
 main
   = >>
       @IO
       $fMonadIO
       @()
       @()
       (print @Bool $fShowBool (g (+ @Int $fNumInt (f x) y)))
       (>>
          @IO
          $fMonadIO
          @()
          @()
          (print
             @(MyData Bool Int)
             ($fShowMyData @Bool @Int $fShowBool $fShowInt)
             (mapMyData @Int @Int @Bool @Int fn_md md1))
          (>>
             @IO
             $fMonadIO
             @()
             @()
             (print @Int $fShowInt (sumMyData @Int @Int md1))
             (>>
                @IO
                $fMonadIO
                @()
                @()
                (print
                   @Int
                   $fShowInt
                   (sumMyData @Bool @Int (mapMyData @Int @Int @Bool @Int fn_md md1)))
                (print
                   @Int
                   $fShowInt
                   (sumMyData
                      @Bool @Int (mapMyData @Int @Int @Bool @Int fn_md md1))))))

(2) when using the Example plugin, we observe that the Main modules core now looks like this:

 main :: IO ()
 [LclIdX,
  Unf=Unf{Src=<vanilla>, TopLvl=True, Value=False, ConLike=False,
          WorkFree=False, Expandable=False, Guidance=IF_ARGS [] 670 0}]
 main
   = >>
       @IO
       $fMonadIO
       @()
       @()
       (print
          @Bool
          $fShowBool
          (case + @Int
                  $fNumInt
                  (+ @Int $fNumInt (I# 1#) (I# 1#))
                  (+ @Int $fNumInt x (I# 2#))
           of
           { I# ds ->
           case ds of {
             __DEFAULT -> False;
             0# -> True
           }
           }))
       (>>
          @IO
          $fMonadIO
          @()
          @()
          (print
             @(MyData Bool Int)
             ($fShowMyData @Bool @Int $fShowBool $fShowInt)
             (mapMyData @Int @Int @Bool @Int fn_md md1))
          (>>
             @IO
             $fMonadIO
             @()
             @()
             (print @Int $fShowInt (sumMyData @Int @Int md1))
             (>>
                @IO
                $fMonadIO
                @()
                @()
                (print
                   @Int
                   $fShowInt
                   (sumMyData @Bool @Int (mapMyData @Int @Int @Bool @Int fn_md md1)))
                (print
                   @Int
                   $fShowInt
                   (sumMyData
                      @Bool @Int (mapMyData @Int @Int @Bool @Int fn_md md1))))))

Please observe that we can see in (2), that the following expression from (1)

g (+ @Int $fNumInt (f x) y)

was replaced by

case + @Int
                  $fNumInt
                  (+ @Int $fNumInt (I# 1#) (I# 1#))
                  (+ @Int $fNumInt x (I# 2#))
           of
           { I# ds ->
           case ds of {
             __DEFAULT -> False;
             0# -> True
           }
           }

If we now treat Lib as it's own cabal package, this also works - with identical results. This is because the loading process is agnostic to package, so as long as the bindings exist, they will be loaded. In the case of one-shot compilation, modules appear as external anyway, so we would have to explicitly test for external package names if we wanted (for some reason) to exclude this working outside of the home package.

[angerman]

Left some comments. So far so good. Will need to be adapted to the new changes where the Plugin has control over the written out core info.

[michaelpj]

Looks generally good!

[michaelpj]

As discussed on Slack, this is the bit we really need to control via a GHC flag if we can.

[michaelpj]

Just checking: is this stuff documented in GHC for less savvy users?

[michaelpj]

Another advantage of having this in GHC would be hiding this stuff from poor users 😅 although for our usecase it's fine if it's hairy.

[michaelpj]

Just while I'm here, I'd probably write something like:

Rec <$> for pairs $ \(n, b) -> (n,) <$> inlineCoreExpr lookup b

[michaelpj]

What about recursive bindings?

[michaelpj]

You can do the same trick with for to make inlining goAlts palatable.

[michaelpj]

🤔

Is this really right? What about

odd = ... even ...
even = ... odd ...

?

[michaelpj]

This is fine. Although it also depends when we do the serialization of the ModGuts for dependent modules, no? If we do it before we do lots of optimization then we'll also get unoptimized code from them. I think we probably should do it relatively early, but I'm not sure.

[michaelpj]

It handles this already, so that's fine.

[michaelpj]

INLINABLE