[GHC] #7091: DPH Matrix product memory usage

[GHC]

#7091: DPH Matrix product memory usage
--------------------------------------+-------------------------------------
    Reporter:  mblanco                |       Owner:                         
        Type:  bug                    |      Status:  new                    
    Priority:  normal                 |   Milestone:                         
   Component:  Data Parallel Haskell  |     Version:  7.4.1                  
    Keywords:                         |          Os:  Linux                  
Architecture:  x86                    |     Failure:  Runtime performance bug
  Difficulty:  Unknown                |    Testcase:                         
   Blockedby:                         |    Blocking:                         
     Related:                         |  
--------------------------------------+-------------------------------------
Changes (by igloo):

  * difficulty:  => Unknown


Old description:

> This report is from the post at Haskell-cafe "DPH matrix product", I'm
> reporting it here so developers can define if it's a bug or not and its
> priority.
>
> On a (I think) standar implementation of matrix product on DPH I notice
> an excessive use of system memory.
> At execution time, on matrices of size 300*300 the program does finish
> (although it is very slow), but on 600*600 it consumes GBs of RAM until
> the process is aborted.
>
> This is the system information:
>
> - Ubuntu 12.04 32-bit
>
> - Intel® Core™2 Duo CPU T5270 @ 1.40GHz × 2
>
> - 2.9 GiB RAM
>
> GHC version:
>
> - GHC 7.4.1
>
> DPH libraries:
>
> - dph-base-0.6.1.1
>
> - (dph-lifted-base-0.6.1.1)
>
> - (dph-lifted-vseg-0.6.1.2)
>
> - (dph-prim-interface-0.6.1.1)
>
> - (dph-prim-par-0.6.1.1)
>
> - (dph-prim-seq-0.6.1.1)
>
> Compilation flags:
>
> I'm using two combinations of flags, taken from different sources. In
> both cases results are identical:
>
> - From https://github.com/ghc/packages-dph: -rtsopts -threaded -fllvm
> -optlo-O3 -Odph -fcpr-off -fno-liberate-case -package dph-lifted-vseg
>
> - From dph-examples: -rtsopts -threaded -fllvm -Odph -package dph-lifted-
> vseg -fcpr-off -fno-liberate-case -fsimpl-tick-factor=1000
>
> Execution flags:
>
> +RTS -N
>
> Tests:
>
> - Computing the product of two 400*400 matrices takes 6.037993 seconds.
>
> - Computing the product of two 600*600 matrices yields "out of memory
> (requested 1728053248 bytes)".
>
> DPH code:
>
> ----------------------------------------------------------------
> {-# LANGUAGE ParallelArrays, ParallelListComp #-}
>
> {-# OPTIONS -fvectorise #-}
>
> module DPH_mmult_wrapper (matMult_wrapper, Matrix_wrapper) where
>
> import qualified Prelude
>
> import Data.Array.Parallel
>
> import Data.Array.Parallel.Prelude.Double as D
>
> import Data.Array.Parallel.Prelude.Int as I
>
> type MMultType = Double
>
> type Matrix = [:[:MMultType:]:]
>
> type MVector = [:MMultType:]
>
> type Matrix_wrapper = PArray (PArray MMultType)
>
> -- matMult_wrapper assumes mB is already transposed
>
> {-# NOINLINE matMult_wrapper #-}
>
> matMult_wrapper :: Matrix_wrapper -> Matrix_wrapper -> Matrix_wrapper
>
> matMult_wrapper mA mB = toPArrayP (mapP toPArrayP (matMult
> (fromNestedPArrayP mA) (fromNestedPArrayP mB)))
>
> matMult :: Matrix -> Matrix -> Matrix
>
> matMult mA mB = mapP (\row -> mapP (\col -> dotp row col) mB) mA
>
> dotp :: MVector -> MVector -> MMultType
>
> dotp row col = D.sumP (zipWithP (D.*) row col)
>
> ----------------------------------------------------------------
>
> I'm reporting this as I think it is the kind of problems intended to be
> solved in the last definition of the internal DPH structure (the one from
> "Work Efficient Higher-Order Vectorisation" paper).
>
> If there is any information missing, please comment and I will update the
> report.
>
> Thanks.

New description:

 This report is from the post at Haskell-cafe "DPH matrix product", I'm
 reporting it here so developers can define if it's a bug or not and its
 priority.

 On a (I think) standar implementation of matrix product on DPH I notice an
 excessive use of system memory.
 At execution time, on matrices of size 300*300 the program does finish
 (although it is very slow), but on 600*600 it consumes GBs of RAM until
 the process is aborted.

 This is the system information:

 - Ubuntu 12.04 32-bit

 - Intel® Core™2 Duo CPU T5270 @ 1.40GHz × 2

 - 2.9 GiB RAM

 GHC version:

 - GHC 7.4.1

 DPH libraries:

 - dph-base-0.6.1.1

 - (dph-lifted-base-0.6.1.1)

 - (dph-lifted-vseg-0.6.1.2)

 - (dph-prim-interface-0.6.1.1)

 - (dph-prim-par-0.6.1.1)

 - (dph-prim-seq-0.6.1.1)

 Compilation flags:

 I'm using two combinations of flags, taken from different sources. In both
 cases results are identical:

 - From https://github.com/ghc/packages-dph: -rtsopts -threaded -fllvm
 -optlo-O3 -Odph -fcpr-off -fno-liberate-case -package dph-lifted-vseg

 - From dph-examples: -rtsopts -threaded -fllvm -Odph -package dph-lifted-
 vseg -fcpr-off -fno-liberate-case -fsimpl-tick-factor=1000

 Execution flags:

 +RTS -N

 Tests:

 - Computing the product of two 400*400 matrices takes 6.037993 seconds.

 - Computing the product of two 600*600 matrices yields "out of memory
 (requested 1728053248 bytes)".

 DPH code:

 {{{
 {-# LANGUAGE ParallelArrays, ParallelListComp #-}

 {-# OPTIONS -fvectorise #-}

 module DPH_mmult_wrapper (matMult_wrapper, Matrix_wrapper) where

 import qualified Prelude

 import Data.Array.Parallel

 import Data.Array.Parallel.Prelude.Double as D

 import Data.Array.Parallel.Prelude.Int as I

 type MMultType = Double

 type Matrix = [:[:MMultType:]:]

 type MVector = [:MMultType:]

 type Matrix_wrapper = PArray (PArray MMultType)

 -- matMult_wrapper assumes mB is already transposed

 {-# NOINLINE matMult_wrapper #-}

 matMult_wrapper :: Matrix_wrapper -> Matrix_wrapper -> Matrix_wrapper

 matMult_wrapper mA mB = toPArrayP (mapP toPArrayP (matMult
 (fromNestedPArrayP mA) (fromNestedPArrayP mB)))

 matMult :: Matrix -> Matrix -> Matrix

 matMult mA mB = mapP (\row -> mapP (\col -> dotp row col) mB) mA

 dotp :: MVector -> MVector -> MMultType

 dotp row col = D.sumP (zipWithP (D.*) row col)
 }}}

 I'm reporting this as I think it is the kind of problems intended to be
 solved in the last definition of the internal DPH structure (the one from
 "Work Efficient Higher-Order Vectorisation" paper).

 If there is any information missing, please comment and I will update the
 report.

 Thanks.

--

-- 
Ticket URL: <http://hackage.haskell.org/trac/ghc/ticket/7091#comment:1>
GHC <http://www.haskell.org/ghc/>
The Glasgow Haskell Compiler