Add pragmas to functions that -fprof-late-overloaded-calls reports

as breaking the chain of specialization (but it's currently broken,
so these may be false positives, but these pragmas may be handy
in the future anyway and they can't do much harm in theory
and in practice they are right now neutral performance-wise).

1 files changed, 10 insertions, 0 deletions

diff --git a/src/Data/Array/Nested/Ranked.hs b/src/Data/Array/Nested/Ranked.hs
index 8faff6d..b448685 100644
--- a/src/Data/Array/Nested/Ranked.hs
+++ b/src/Data/Array/Nested/Ranked.hs
@@ -94,6 +94,7 @@ rlift2 :: forall n1 n2 n3 a. Elt a
        -> Ranked n1 a -> Ranked n2 a -> Ranked n3 a
 rlift2 sn3 f (Ranked arr1) (Ranked arr2) = Ranked (mlift2 (ssxFromSNat sn3) f arr1 arr2)
 
+{-# INLINE rsumOuter1PrimP #-}
 rsumOuter1PrimP :: forall n a.
                    (Storable a, NumElt a)
                 => Ranked (n + 1) (Primitive a) -> Ranked n (Primitive a)
@@ -101,13 +102,16 @@ rsumOuter1PrimP (Ranked arr)
   | Refl <- lemReplicateSucc @(Nothing @Nat) (Proxy @n)
   = Ranked (msumOuter1PrimP arr)
 
+{-# INLINEABLE rsumOuter1Prim #-}
 rsumOuter1Prim :: forall n a. (NumElt a, PrimElt a)
                => Ranked (n + 1) a -> Ranked n a
 rsumOuter1Prim = rfromPrimitive . rsumOuter1PrimP . rtoPrimitive
 
+{-# INLINE rsumAllPrimP #-}
 rsumAllPrimP :: (Storable a, NumElt a) => Ranked n (Primitive a) -> a
 rsumAllPrimP (Ranked arr) = msumAllPrimP arr
 
+{-# INLINE rsumAllPrim #-}
 rsumAllPrim :: (PrimElt a, NumElt a) => Ranked n a -> a
 rsumAllPrim (Ranked arr) = msumAllPrim arr
 
@@ -139,17 +143,21 @@ rappend arr1 arr2
 rscalar :: Elt a => a -> Ranked 0 a
 rscalar x = Ranked (mscalar x)
 
+{-# INLINEABLE rfromVectorP #-}
 rfromVectorP :: forall n a. Storable a => IShR n -> VS.Vector a -> Ranked n (Primitive a)
 rfromVectorP sh v
   | Dict <- lemKnownReplicate (shrRank sh)
   = Ranked (mfromVectorP (shxFromShR sh) v)
 
+{-# INLINEABLE rfromVector #-}
 rfromVector :: forall n a. PrimElt a => IShR n -> VS.Vector a -> Ranked n a
 rfromVector sh v = rfromPrimitive (rfromVectorP sh v)
 
+{-# INLINEABLE rtoVectorP #-}
 rtoVectorP :: Storable a => Ranked n (Primitive a) -> VS.Vector a
 rtoVectorP = coerce mtoVectorP
 
+{-# INLINEABLE rtoVector #-}
 rtoVector :: PrimElt a => Ranked n a -> VS.Vector a
 rtoVector = coerce mtoVector
 
@@ -335,6 +343,7 @@ rmaxIndexPrim rarr@(Ranked arr)
   | Refl <- lemRankReplicate (rrank (rtoPrimitive rarr))
   = ixrFromIxX (mmaxIndexPrim arr)
 
+{-# INLINEABLE rdot1Inner #-}
 rdot1Inner :: forall n a. (PrimElt a, NumElt a) => Ranked (n + 1) a -> Ranked (n + 1) a -> Ranked n a
 rdot1Inner arr1 arr2
   | SNat <- rrank arr1
@@ -343,6 +352,7 @@ rdot1Inner arr1 arr2
 
 -- | This has a temporary, suboptimal implementation in terms of 'mflatten'.
 -- Prefer 'rdot1Inner' if applicable.
+{-# INLINE rdot #-}
 rdot :: (PrimElt a, NumElt a) => Ranked n a -> Ranked n a -> a
 rdot = coerce mdot