Comments on: Collatz, Haskell and Memoization http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382 Drinker of tea Fri, 14 Jun 2013 11:08:30 +0000 hourly 1 By: Anonymous http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-4119 Anonymous Thu, 16 Feb 2012 02:35:00 +0000 http://swizec.com/blog/?p=3382#comment-4119  So, after playing around with this for a while, and trying various different ways to memoize the result, I've come to the conclusion that memoization is a bad idea for this problem. You actually saw this yourself in your "fixed" version of the app, that Killed message was the OS informing you that it nuked the process from orbit for using too much memory. If you ran something like top (I like htop) you'd see the process quickly gobble up every last shred of memory available, and then get killed off by the OS. The final non-memoized version I came up with can be found here: https://gist.github.com/1841085 I probably don't need to use a couple of those $!, and there's probably an existing way to do "x `seq` x", but on the whole it seems fairly stable. When run it exhibits constant memory usage which shows it's not leaking thunks anywhere. If you really really wanted to use memoization your best bet would be to either find or create a memoization library that allows you to set an upper bound on memory usage for the result cache, otherwise it's just going to keep getting killed by the OS.  So, after playing around with this for a while, and trying various different ways to memoize the result, I’ve come to the conclusion that memoization is a bad idea for this problem. You actually saw this yourself in your “fixed” version of the app, that Killed message was the OS informing you that it nuked the process from orbit for using too much memory. If you ran something like top (I like htop) you’d see the process quickly gobble up every last shred of memory available, and then get killed off by the OS.

The final non-memoized version I came up with can be found here:
https://gist.github.com/1841085

I probably don’t need to use a couple of those $!, and there’s probably an existing way to do “x `seq` x”, but on the whole it seems fairly stable. When run it exhibits constant memory usage which shows it’s not leaking thunks anywhere. If you really really wanted to use memoization your best bet would be to either find or create a memoization library that allows you to set an upper bound on memory usage for the result cache, otherwise it’s just going to keep getting killed by the OS.

]]> By: Anonymous http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-4118 Anonymous Wed, 15 Feb 2012 22:05:00 +0000 http://swizec.com/blog/?p=3382#comment-4118 You're still not calling the memoized function. Try this instead: collatz :: Integer -> [Integer] collatz = memoFix col where   col _ 1 = []   col f n     | odd n = 3*n+1:f $! 3*n+1 | even n = div n 2:f $! div n 2 I haven't actually run this code yet as I'm at work, but when I get home I'll give it a run through and make sure I didn't screw anything up. (Edit: Had to fix this post as the formatting got all screwed up) (Edit2: Formatting is still screwed up, when I get home I'll make a GIST of this and link that, you should still be able to get the general idea from this though) You’re still not calling the memoized function. Try this instead:

collatz :: Integer -> [Integer]
collatz = memoFix col
where  
col _ 1 = []
  col f n    
| odd n = 3*n+1:f $! 3*n+1
| even n = div n 2:f $! div n 2

I haven’t actually run this code yet as I’m at work, but when I get home I’ll give it a run through and make sure I didn’t screw anything up.
(Edit: Had to fix this post as the formatting got all screwed up)
(Edit2: Formatting is still screwed up, when I get home I’ll make a GIST of this and link that, you should still be able to get the general idea from this though)

]]> By: Swizec http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-4117 Swizec Wed, 15 Feb 2012 21:03:00 +0000 http://swizec.com/blog/?p=3382#comment-4117 Thanks for the suggestions! As mentioned I don't really understand performance in haskell yet. Not sure why I didn't link it in the blog, but here's the full code: https://github.com/Swizec/random-coding/blob/master/project-euler/14.hs Thanks for the suggestions! As mentioned I don’t really understand performance in haskell yet.

Not sure why I didn’t link it in the blog, but here’s the full code: https://github.com/Swizec/random-coding/blob/master/project-euler/14.hs

]]> By: Anonymous http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-4116 Anonymous Wed, 15 Feb 2012 20:39:00 +0000 http://swizec.com/blog/?p=3382#comment-4116 Sorry to necro this, but I just got around to looking through your blog after a few months of ignoring it and this jumped out at me. I'd be willing to bet you're chewing through too much memory because of all the thunks you're building up. You've probably seen this, but it's worth pointing out: http://www.haskell.org/haskellwiki/Memoization Being lazy is both the biggest strength, and biggest weakness of Haskell. By defaulting to lazy Haskell implicitly trades time complexity for space complexity (by deferring processing till absolutely necessary and instead building thunks in memory). This is often useful, but anytime you perform any sort of looping or recursion you run the danger of building monstrous thunk chains when you really don't need to. Judicious use of $!, BangPatterns, strict folds, and seq can go a long way towards performance improvements as well as in the best case lead to constant memory usage. I must confess I don't fully understand the algorithm you've provided in part because several chunks of it are missing, so I can't say for sure exactly where the problem is. Sorry to necro this, but I just got around to looking through your blog after a few months of ignoring it and this jumped out at me. I’d be willing to bet you’re chewing through too much memory because of all the thunks you’re building up.

You’ve probably seen this, but it’s worth pointing out: http://www.haskell.org/haskellwiki/Memoization

Being lazy is both the biggest strength, and biggest weakness of Haskell. By defaulting to lazy Haskell implicitly trades time complexity for space complexity (by deferring processing till absolutely necessary and instead building thunks in memory). This is often useful, but anytime you perform any sort of looping or recursion you run the danger of building monstrous thunk chains when you really don’t need to. Judicious use of $!, BangPatterns, strict folds, and seq can go a long way towards performance improvements as well as in the best case lead to constant memory usage.

I must confess I don’t fully understand the algorithm you’ve provided in part because several chunks of it are missing, so I can’t say for sure exactly where the problem is.

]]> By: A geek with a hat » This Haskell is wrong. Why? http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-4027 A geek with a hat » This Haskell is wrong. Why? Fri, 20 Jan 2012 17:47:45 +0000 http://swizec.com/blog/?p=3382#comment-4027 [...] Collatz, Haskell and Memoization (swizec.com) [...] [...] Collatz, Haskell and Memoization (swizec.com) [...]

]]> By: Swizec http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-3993 Swizec Tue, 10 Jan 2012 11:22:00 +0000 http://swizec.com/blog/?p=3382#comment-3993 Yes but you actually know how to use python whereas I have no idea how haskell works :P Did you bruteforce it? Yes but you actually know how to use python whereas I have no idea how haskell works :P

Did you bruteforce it?

]]> By: Smotko http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-3992 Smotko Tue, 10 Jan 2012 10:47:00 +0000 http://swizec.com/blog/?p=3382#comment-3992 I guess there is still a lot more room for improvements as even my python solution seems to be faster than yours. But I must admit, the haskell solutions look way more cooler :D I guess there is still a lot more room for improvements as even my python solution seems to be faster than yours. But I must admit, the haskell solutions look way more cooler :D

]]> By: Swizec http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-3990 Swizec Mon, 09 Jan 2012 18:33:00 +0000 http://swizec.com/blog/?p=3382#comment-3990 14. 14.

]]> By: Smotko http://swizec.com/blog/collatz-haskell-and-memoization/swizec/3382/comment-page-1#comment-3989 Smotko Mon, 09 Jan 2012 18:25:00 +0000 http://swizec.com/blog/?p=3382#comment-3989 Which Euler problem is this? Which Euler problem is this?

]]>