The entire topic of space use in Haskell is not simple, but the part you need here may be. As long as GHC can tell that values already written to disk may be garbage collected, memory use is quite reasonable. For example, here's a short program that prints a long-ish list: xs :: [Double] xs = map cos [1..1e7] main :: IO () main = traverse_ print $ map sin xs It runs in constant space, of less than 1 MB. (I ran it on a few smaller cases to confirm that max residency stays the same order of magnitude.) Note the difference between "bytes allocated" and "total memory in use". $ ./laziness +RTS -sstderr > /dev/null 181,493,398,808 bytes allocated in the heap 414,623,400 bytes copied during GC 131,736 bytes maximum residency (2 sample(s)) 23,520 bytes maximum slop 1 MB total memory in use (0 MB lost due to fragmentation) This next program generates random numbers. You could use the State monad; here I've just used the infinite list generator in System.Random. main = do g <- newStdGen let xs = take 100000 (randoms g) :: [Int] traverse_ print xs This one also runs in constant space: $ ./.cabal-sandbox/bin/lazyRandom +RTS -sstderr > /dev/null 380,128,240 bytes allocated in the heap 238,472 bytes copied during GC 44,312 bytes maximum residency (2 sample(s)) 21,224 bytes maximum slop 1 MB total memory in use (0 MB lost due to fragmentation) Based on these tests, I'd recommend trying to structure your program as a map or fold over a (lazy) list. If that structure makes sense for your problem, I'd expect managing memory usage to be as simple as the cases above. I expect that memory usage will be constant in the number of samples, although higher than my examples because each sample is bigger than the Int or Double I used. Let me know if you want me to elaborate on any of this. bergey On 2016-04-29 at 23:58, Dennis Raddle <dennis.raddle@gmail.com> wrote:
I'm writing a program that will use functions to generate audio. The Haskell code will write the audio samples to disk---no need for real time playback. I see some useful libraries for writing audio files.
My question concerns efficiency when generating several million to 20 million samples (or even many times more than that if I use high-resolution sampling rates). They can be generated one at a time in sequence, so there's no need to occupy a lot of memory or postpone thunk evaluation. I'm going to need efficient disk writing. Note that I may need some pseudorandom numbers in my calculations, so I might want to calculate samples by state monadic computations to carry the generator state. What is my general strategy going to be for memory and time efficiency? I am pretty confused by Haskell "strictness" and normal head form and all that, which often doesn't seem to be very strict. Or bang patterns, etc. Is it going to be simple to understand what I need?
Dennis
_______________________________________________ Beginners mailing list Beginners@haskell.org http://mail.haskell.org/cgi-bin/mailman/listinfo/beginners