[GHC] #10812: High memory usage

[GHC]

#10812: High memory usage
---------------------------------+-----------------------------------------
        Reporter:  danilo2       |                   Owner:
            Type:  bug           |                  Status:  new
        Priority:  high          |               Milestone:
       Component:  Compiler      |                 Version:  7.10.2
      Resolution:                |                Keywords:
Operating System:  MacOS X       |            Architecture:  x86_64 (amd64)
 Type of failure:  None/Unknown  |               Test Case:
      Blocked By:                |                Blocking:
 Related Tickets:                |  Differential Revisions:
---------------------------------+-----------------------------------------
Description changed by danilo2:

Old description:

> Hello, lets consider following program:
>
> {{{
> {-# LANGUAGE NoMonomorphismRestriction #-}
>
> import System.Mem.Weak
> import Control.Concurrent
> import System.Mem
>
> data Tst a = Tst a deriving (Show, Eq)
>
> tst a = do
>     let arr = [0 .. a*a*a]
>         v = Tst (seq arr arr)
>     ptr <- mkWeakPtr v Nothing
>     return ptr
>
> main = do
>     ptrs <- mapM tst [1..100000000]
>     --performGC
>     --performMajorGC
>     --performMinorGC
>     threadDelay 1000000
>     xr <- mapM deRefWeak ptrs
>     print $ length $ filter (/= Nothing) xr
>
>     threadDelay 5000000
>
>     return ()
> }}}
>
> It simply creates 10 million of weak references to values of {{{Tst}}}.
> These weak pointers are returned in the main function. After that we
> sleep a second and ask how meany references are alive. I get the {{{0}}}
> as a result here - so everything seems ok - garbage collection worked.
> There is a problem though - somehow the memory was not released, because
> on the second 5-second sleep the program uses over 14 Gb of RAM on my
> computer.
>
> I'm compiling it simply with {{{ghc -O2 Main.hs}}}. I'm pretty sure this
> is a bug, because such behaviour is not expected I think.

New description:

 Hello, lets consider following program:

 {{{
 {-# LANGUAGE NoMonomorphismRestriction #-}

 import System.Mem.Weak
 import Control.Concurrent
 import System.Mem

 data Tst a = Tst a deriving (Show, Eq)

 tst a = do
     let arr = [0 .. a*a*a]
         v = Tst (seq arr arr)
     ptr <- mkWeakPtr v Nothing
     return ptr

 main = do
     ptrs <- mapM tst [1..100000000]
     --performGC
     --performMajorGC
     --performMinorGC
     threadDelay 1000000
     xr <- mapM deRefWeak ptrs
     print $ length $ filter (/= Nothing) xr

     threadDelay 5000000

     return ()
 }}}

 It simply creates 10 million of weak references to values of {{{Tst}}}.
 These weak pointers are returned in the main function. After that we sleep
 a second and ask how meany references are alive. I get the {{{0}}} as a
 result here - so everything seems ok - garbage collection worked. There is
 a problem though - somehow the memory was not released, because during the
 last 5-second sleep the program uses over 14 Gb of RAM on my computer.

 I'm compiling it simply with {{{ghc -O2 Main.hs}}}. I'm pretty sure this
 is a bug, because such behaviour is not expected I think.

--

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