dph-prim-par: enable -Wall and fix all warnings
authorBen Lippmeier <benl@ouroborus.net>
Fri, 16 Dec 2011 03:44:58 +0000 (14:44 +1100)
committerBen Lippmeier <benl@ouroborus.net>
Fri, 16 Dec 2011 03:44:58 +0000 (14:44 +1100)
dph-prim-par/Data/Array/Parallel/Unlifted.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Basics.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Combinators.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Enum.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Extracts.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Segmented.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Sums.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/Text.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSegd.hs
dph-prim-par/Data/Array/Parallel/Unlifted/Parallel/UPSel.hs
dph-prim-par/dph-prim-par.cabal

index c00f03c..b5f1cae 100644 (file)
@@ -1,4 +1,5 @@
 {-# LANGUAGE PackageImports, CPP, NoMonomorphismRestriction #-}
+{-# OPTIONS -fno-warn-missing-signatures #-}
 
 -- | Primitive parallel combinators that work on flat, unlifted arrays.
 --   Some of them don't actually have parallel implementations, so we bail out
index 159d049..fb532fa 100644 (file)
@@ -30,7 +30,7 @@ replicateUP :: Unbox e => Int -> e -> Vector e
 {-# INLINE_UP replicateUP #-}
 replicateUP n !e 
         = joinD theGang balanced
-        . mapD theGang (\n ->Seq.replicate n e)
+        . mapD theGang (\n' ->Seq.replicate n' e)
         $ splitLenD theGang n
 
 
index 6a5e335..2e105a2 100644 (file)
@@ -141,15 +141,15 @@ foldl1UP :: (DT a, Unbox a) => (a -> a -> a) -> Vector a -> a
 {-# INLINE_UP foldl1UP #-}
 foldl1UP f arr 
         = (maybe z (f z)
-        . foldD  theGang combine
+        . foldD  theGang combine'
         . mapD   theGang (Seq.foldl1Maybe f)
         . splitD theGang unbalanced) arr
         where
                 z = Seq.index (here "fold1UP") arr 0
-                combine (Just x) (Just y) = Just (f x y)
-                combine (Just x) Nothing  = Just x
-                combine Nothing  (Just y) = Just y
-                combine Nothing  Nothing  = Nothing
+                combine' (Just x) (Just y) = Just (f x y)
+                combine' (Just x) Nothing  = Just x
+                combine' Nothing  (Just y) = Just y
+                combine' Nothing  Nothing  = Nothing
 
 
 -- | Prefix scan. Similar to fold, but produce an array of the intermediate states.
index 03b3bc2..02d5c3f 100644 (file)
@@ -52,7 +52,7 @@ enumFromStepLenUP start delta len =
 
 enumFromStepLenEachUP :: Int -> Vector Int -> Vector Int -> Vector Int -> Vector Int
 {-# INLINE_UP enumFromStepLenEachUP #-}
-enumFromStepLenEachUP n starts steps lens
+enumFromStepLenEachUP _n starts steps lens
   = joinD theGang unbalanced
   $ mapD theGang enum
   $ splitD theGang unbalanced (Seq.zip (Seq.zip starts steps) lens)
index 5e10433..688cdeb 100644 (file)
@@ -11,25 +11,16 @@ module Data.Array.Parallel.Unlifted.Parallel.Extracts
         , extractsFromVectorsWithUPSSegd
         , extractsFromVectorsWithUPVSegd)
 where
-import Data.Array.Parallel.Unlifted.Distributed
-import Data.Array.Parallel.Unlifted.Parallel.Basics
-import Data.Array.Parallel.Unlifted.Parallel.UPSegd                     (UPSegd)
 import Data.Array.Parallel.Unlifted.Parallel.UPSSegd                    (UPSSegd)
 import Data.Array.Parallel.Unlifted.Parallel.UPVSegd                    (UPVSegd)
-import Data.Array.Parallel.Unlifted.Sequential.USegd                    (USegd)
 import Data.Array.Parallel.Unlifted.Sequential.Vector                   as Seq
 import Data.Array.Parallel.Unlifted.Vectors                             (Vectors)
-import qualified Data.Array.Parallel.Unlifted.Parallel.UPSegd           as UPSegd
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSSegd          as UPSSegd
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPVSegd          as UPVSegd
 import qualified Data.Array.Parallel.Unlifted.Sequential.UVSegd         as UVSegd
 import qualified Data.Array.Parallel.Unlifted.Vectors                   as US
 import qualified Data.Array.Parallel.Unlifted.Stream                    as US
 import qualified Data.Array.Parallel.Unlifted.Sequential                as Seq
-import qualified Data.Array.Parallel.Unlifted.Sequential.USegd          as USegd
-import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..) )
-import Data.Vector.Fusion.Stream.Size    ( Size(..) )
-import qualified Data.Vector.Fusion.Stream                              as S
 import qualified Data.Vector                                            as V
 
 
index c195408..8f07e5e 100644 (file)
@@ -11,23 +11,14 @@ where
 import Data.Array.Parallel.Unlifted.Distributed
 import Data.Array.Parallel.Unlifted.Parallel.Basics
 import Data.Array.Parallel.Unlifted.Parallel.UPSegd                     (UPSegd)
-import Data.Array.Parallel.Unlifted.Parallel.UPSSegd                    (UPSSegd)
-import Data.Array.Parallel.Unlifted.Parallel.UPVSegd                    (UPVSegd)
 import Data.Array.Parallel.Unlifted.Sequential.USegd                    (USegd)
 import Data.Array.Parallel.Unlifted.Sequential.Vector                   as Seq
-import Data.Array.Parallel.Unlifted.Vectors                             (Vectors)
 import qualified Data.Array.Parallel.Unlifted.Parallel.UPSegd           as UPSegd
-import qualified Data.Array.Parallel.Unlifted.Parallel.UPSSegd          as UPSSegd
-import qualified Data.Array.Parallel.Unlifted.Parallel.UPVSegd          as UPVSegd
-import qualified Data.Array.Parallel.Unlifted.Sequential.UVSegd         as UVSegd
-import qualified Data.Array.Parallel.Unlifted.Vectors                   as US
-import qualified Data.Array.Parallel.Unlifted.Stream                    as US
 import qualified Data.Array.Parallel.Unlifted.Sequential                as Seq
 import qualified Data.Array.Parallel.Unlifted.Sequential.USegd          as USegd
 import Data.Vector.Fusion.Stream.Monadic ( Stream(..), Step(..) )
 import Data.Vector.Fusion.Stream.Size    ( Size(..) )
 import qualified Data.Vector.Fusion.Stream                              as S
-import qualified Data.Vector                                            as V
 
 here :: String -> String
 here s = "Data.Array.Parallel.Unlifted.Parallel.Segmented." Prelude.++ s
@@ -60,11 +51,11 @@ appendSUP segd !xd !xs !yd !ys
   = joinD theGang balanced
   . mapD  theGang append
   $ UPSegd.takeDistributed segd
-  where append ((segd,seg_off),el_off)
+  where append ((segd',seg_off),el_off)
          = Seq.unstream
          $ appendSegS (UPSegd.takeUSegd xd) xs
                       (UPSegd.takeUSegd yd) ys
-                      (USegd.takeElements segd)
+                      (USegd.takeElements segd')
                       seg_off el_off
 
 -- append ---------------------------------------------------------------------
@@ -86,44 +77,44 @@ appendSegS !xd !xs !yd !ys !n seg_off el_off
     !xlens = USegd.takeLengths xd
     !ylens = USegd.takeLengths yd
 
-    {-# INLINE index #-}
-    index  = Seq.index (here "appendSegS")
+    {-# INLINE index1 #-}
+    index1  = Seq.index (here "appendSegS")
 
-    {-# INLINE index' #-}
-    index'  = Seq.index (here "appendSegS")
+    {-# INLINE index2 #-}
+    index2  = Seq.index (here "appendSegS")
     
     state
       | n == 0 = Nothing
-      | el_off < xlens `index` seg_off
-      = let i = (USegd.takeIndices xd `index` seg_off) + el_off
-            j =  USegd.takeIndices yd `index` seg_off
-            k = (USegd.takeLengths xd `index` seg_off) - el_off
+      | el_off < xlens `index1` seg_off
+      = let i = (USegd.takeIndices xd `index1` seg_off) + el_off
+            j =  USegd.takeIndices yd `index1` seg_off
+            k = (USegd.takeLengths xd `index1` seg_off) - el_off
         in  Just (False, seg_off, i, j, k, n)
 
       | otherwise
       = let -- NOTE: *not* indicesUSegd xd ! (seg_off+1) since seg_off+1
             -- might be out of bounds
-            i       = (USegd.takeIndices xd `index` seg_off) + (USegd.takeLengths xd `index` seg_off)
-            el_off' = el_off - USegd.takeLengths xd `index` seg_off
-            j       = (USegd.takeIndices yd `index` seg_off) + el_off'
-            k       = (USegd.takeLengths yd `index` seg_off) - el_off'
+            i       = (USegd.takeIndices xd `index1` seg_off) + (USegd.takeLengths xd `index1` seg_off)
+            el_off' = el_off - USegd.takeLengths xd `index1` seg_off
+            j       = (USegd.takeIndices yd `index1` seg_off) + el_off'
+            k       = (USegd.takeLengths yd `index1` seg_off) - el_off'
         in  Just (True, seg_off, i, j, k, n)
 
     {-# INLINE next #-}
     next Nothing = return Done
 
-    next (Just (False, seg, i, j, k, n))
-      | n == 0    = return Done
-      | k == 0    = return $ Skip (Just (True, seg, i, j, ylens `index` seg, n))
-      | otherwise = return $ Yield (xs `index'` i) (Just (False, seg, i+1, j, k-1, n-1))
+    next (Just (False, seg, i, j, k, n'))
+      | n' == 0    = return Done
+      | k  == 0    = return $ Skip (Just (True, seg, i, j, ylens `index1` seg, n'))
+      | otherwise  = return $ Yield (xs `index2` i) (Just (False, seg, i+1, j, k-1, n'-1))
 
-    next (Just (True, seg, i, j, k, n))
-      | n == 0    = return Done
-      | k == 0
+    next (Just (True, seg, i, j, k, n'))
+      | n' == 0    = return Done
+      | k  == 0
       = let !seg' = seg+1
-        in  return $ Skip (Just (False, seg', i, j, xlens `index` seg', n))
+        in  return $ Skip (Just (False, seg', i, j, xlens `index1` seg', n'))
 
-      | otherwise = return $ Yield (ys `index'` j) (Just (True, seg, i, j+1, k-1, n-1))
+      | otherwise = return $ Yield (ys `index2` j) (Just (True, seg, i, j+1, k-1, n'-1))
 
 
 -- foldR ----------------------------------------------------------------------
index 1769f02..25649d1 100644 (file)
@@ -60,7 +60,7 @@ maximumByUP :: (DT e, Unbox e) => (e -> e -> Ordering) -> Vector e -> e
 {-# INLINE_UP maximumByUP #-}
 maximumByUP = fold1UP . maxBy
   where
-    maxBy compare x y = case x `compare` y of
+    maxBy compare' x y = case x `compare'` y of
                           LT -> y
                           _  -> x
 
index 4b12f09..f7abd3e 100644 (file)
@@ -1,11 +1,10 @@
+{-# OPTIONS -fno-warn-orphans #-}
 -- | Read\/Show instances for segmented unlifted arrays.
 module Data.Array.Parallel.Unlifted.Parallel.Text ()
 where
 
-import Data.Array.Parallel.Base (
-  showsApp)
-import Data.Array.Parallel.Unlifted.Parallel.UPSegd (
-  UPSegd, takeLengths )
+import Data.Array.Parallel.Base (showsApp)
+import Data.Array.Parallel.Unlifted.Parallel.UPSegd (UPSegd, takeLengths )
 
 instance Show UPSegd where
-  showsPrec k = showsApp k "toUPSegd" . takeLengths
\ No newline at end of file
+  showsPrec k = showsApp k "toUPSegd" . takeLengths
index 4b5d3b9..f4d64d0 100644 (file)
@@ -182,7 +182,7 @@ indicesP
         . mapD  theGang indices
         . takeDistributed
   where
-    indices ((segd,k),off) = Seq.indicesSU' off segd
+    indices ((segd,_k),off) = Seq.indicesSU' off segd
 {-# NOINLINE indicesP #-}
 --  NOINLINE because we're not using it yet.
 
@@ -252,8 +252,8 @@ foldSegsWithP fElem fSeg segd xs
           $ zipD (takeDistributed segd)
                  (splitD theGang balanced xs)
 
-        partial (((segd, k), off), as)
-         = let rs = fSeg segd as
+        partial (((segd', k), off), as)
+         = let rs = fSeg segd' as
                {-# INLINE [0] n #-}
                n | off == 0  = 0
                  | otherwise = 1
index a113199..a5933ba 100644 (file)
@@ -156,9 +156,9 @@ indicesUPSelRep2 tags rep
              (splitD theGang balanced tags)
               rep
   where
-    indices tags ((i,j), (m,n))
-      = US.combine2ByTag tags (US.enumFromStepLen i 1 m)
-                              (US.enumFromStepLen j 1 n)
+    indices tags' ((i,j), (m,n))
+      = US.combine2ByTag tags' (US.enumFromStepLen i 1 m)
+                               (US.enumFromStepLen j 1 n)
 {-# INLINE_UP indicesUPSelRep2 #-}
 
 
index d1a590f..d3c87df 100644 (file)
@@ -60,8 +60,7 @@ Library
 
   GHC-Options:
         -Odph -funbox-strict-fields
-        -fcpr-off
-        -Werror
+        -fcpr-off -Wall
 
   Build-Depends:  
         base               == 4.4.*,