GALOP

STYLE.md

@@ -85,21 +85,21 @@ Ormolu doesn't enfore the 80 character line limit, so it is up to the user to
 introduce the necessary line breaks in the code. However, Ormolu will take a
 hint. Imagine you've got the following line of code:
 
-```
+```haskell
 onKernels :: (SegOp SegLevel KernelsMem -> ReuseAllocsM (SegOp SegLevel KernelsMem)) -> Stms KernelsMem -> ReuseAllocsM (Stms KernelsMem)
 ```
 
 If the user introduces a newline before `ReuseAllocsM`, turning the above into
 the following:
 
-```
+```haskell
 onKernels :: (SegOp SegLevel KernelsMem -> ReuseAllocsM (SegOp SegLevel KernelsMem)) -> Stms KernelsMem ->
   ReuseAllocsM (Stms KernelsMem)
 ```
 
 Ormolu will pick up the hint and reformat the entire declaration to this:
 
-```
+```haskell
 onKernels ::
   (SegOp SegLevel KernelsMem -> ReuseAllocsM (SegOp SegLevel KernelsMem)) ->
   Stms KernelsMem ->
@@ -140,7 +140,7 @@ If you'd rather keep everything equally nested, consider using the `&` operator
 instead, which is like a reverse `$`. The code above is semantically identical
 to this:
 
-```
+```haskell
 someAtrociouslyLongVariableName <-
   map somethingElse
     & someThirdFunction something
@@ -257,7 +257,7 @@ Use camel case (e.g. `functionName`) when naming functions and upper
 camel case (e.g. `DataType`) when naming data types.  Use underscores
 to separate words in variables and parameters.  For compound names
 consisting of just two words, it is acceptable to not separate them at
-all, e.g. `flatarrs` instead of `flat_arrs.  If a variable or
+all, e.g. `flatarrs` instead of `flat_arrs`.  If a variable or
 parameter is also a function, use your judgement as to whether it is
 most like a function or most like a value.
 
@@ -326,13 +326,13 @@ For long comments, we (try to) use the Notes convention from GHC,
 Essentially, instead of writing very long in-line comments that break
 the flow of the code, we write
 
-```
+```haskell
 -- See Note [Foo Bar]
 ```
 
 and then somewhere else in the file (perhaps at the bottom), we put
 
-```
+```haskell
 -- Note [Foo Bar]
 --
 -- Here is how you foo the bar...

futhark.cabal

@@ -167,6 +167,7 @@ library
       Futhark.AD.Rev.Scan
       Futhark.AD.Rev.Scatter
       Futhark.AD.Rev.SOAC
+      Futhark.Analysis.AccessPattern
       Futhark.Analysis.AlgSimplify
       Futhark.Analysis.Alias
       Futhark.Analysis.CallGraph
@@ -178,6 +179,7 @@ library
       Futhark.Analysis.MemAlias
       Futhark.Analysis.Metrics
       Futhark.Analysis.Metrics.Type
+      Futhark.Analysis.Pretty
       Futhark.Analysis.PrimExp
       Futhark.Analysis.PrimExp.Convert
       Futhark.Analysis.PrimExp.Parse
@@ -389,6 +391,7 @@ library
       Futhark.Optimise.Unstream
       Futhark.Pass
       Futhark.Pass.AD
+      Futhark.Pass.CoalesceAccess
       Futhark.Pass.ExpandAllocations
       Futhark.Pass.ExplicitAllocations
       Futhark.Pass.ExplicitAllocations.GPU
@@ -530,6 +533,7 @@ library
     , mwc-random
     , prettyprinter >= 1.7
     , prettyprinter-ansi-terminal >= 1.1
+    , pretty-simple >= 4.1
 
 executable futhark
   import: common

src/Futhark/Actions.hs

@@ -7,6 +7,7 @@ module Futhark.Actions
     printFusionGraph,
     printInterferenceGPU,
     printMemAliasGPU,
+    printMemoryAccessAnalysis,
     callGraphAction,
     impCodeGenAction,
     kernelImpCodeGenAction,
@@ -33,12 +34,14 @@ import Data.Map qualified as M
 import Data.Maybe (fromMaybe)
 import Data.Text qualified as T
 import Data.Text.IO qualified as T
+import Futhark.Analysis.AccessPattern
 import Futhark.Analysis.Alias
 import Futhark.Analysis.CallGraph (buildCallGraph)
 import Futhark.Analysis.Interference qualified as Interference
 import Futhark.Analysis.LastUse qualified as LastUse
 import Futhark.Analysis.MemAlias qualified as MemAlias
 import Futhark.Analysis.Metrics
+import Futhark.Analysis.Pretty
 import Futhark.CodeGen.Backends.CCUDA qualified as CCUDA
 import Futhark.CodeGen.Backends.COpenCL qualified as COpenCL
 import Futhark.CodeGen.Backends.HIP qualified as HIP
@@ -133,6 +136,15 @@ printMemAliasGPU =
       actionProcedure = liftIO . print . MemAlias.analyzeGPUMem
     }
 
+-- | Print result of memory access analysis on the IR
+printMemoryAccessAnalysis :: (Analyze rep) => Action rep
+printMemoryAccessAnalysis =
+  Action
+    { actionName = "call-graph",
+      actionDescription = "Prettyprint the callgraph of the result to standard output.",
+      actionProcedure = liftIO . putStrLn . prettyString . analyzeDimIdxPats
+    }
+
 -- | Print call graph to stdout.
 callGraphAction :: Action SOACS
 callGraphAction =