Memory footprint of Haskell data types

by

(The following applies to GHC, other compilers may use different storage conventions)

Rule of thumb: a constructor costs one word for a header, and one word for each field. Exception: a constructor with no fields (like Nothing or True) takes no space, because GHC creates a single instance of these constructors and shares it amongst all uses.

A word is 4 bytes on a 32-bit machine, and 8 bytes on a 64-bit machine.

So e.g. 

data Uno = Uno a
data Due = Due a b

an Uno takes 2 words, and a Due takes 3.

The Int type is defined as

data Int = I# Int#

now, Int# takes one word, so Int takes 2 in total. Most unboxed types take one word, the exceptions being Int64#, Word64#, and Double# (on a 32-bit machine) which take 2. GHC actually has a cache of small values of type Int and Char, so in many cases these take no heap space at all. A String only requires space for the list cells, unless you use Chars > 255.

An Int8 has identical representation to Int. Integer is defined like this:

data Integer
  = S# Int#                            -- small integers
  | J# Int# ByteArray#                 -- large integers

so a small Integer (S#) takes 2 words, but a large integer takes a variable amount of space depending on its value. A ByteArray# takes 2 words (header + size) plus space for the array itself.

Note that a constructor defined with newtype is free. newtype is purely a compile-time idea, and it takes up no space and costs no instructions at run time.

More details in The Layout of Heap Objects in the GHC Commentary.

More Related Contents:

  1. When is memoization automatic in GHC Haskell?
  2. Small Haskell program compiled with GHC into huge binary
  3. Wrong IO actions order using putStr and getLine
  4. How do you represent a graph in Haskell?
  5. What is fusion in Haskell?
  6. How to make a CAF not a CAF in Haskell?
  7. What does the `forall` keyword in Haskell/GHC do?
  8. Why is GHC complaining about non-exhaustive patterns?
  9. Abusing the algebra of algebraic data types – why does this work?
  10. Is there a list of GHC extensions that are considered ‘safe’?
  11. How to run a for loop in Haskell
  12. Getting started with Haskell
  13. How is this fibonacci-function memoized?
  14. runST and function composition
  15. Explain this chunk of haskell code that outputs a stream of primes
  16. Finite comprehension of an infinite list
  17. Are there pronounceable names for common Haskell operators? [closed]
  18. Split a number into its digits with Haskell
  19. What indentation is required for a case statement within a let statement?
  20. What is the difference between Int and Integer?
  21. Is Haskell truly pure (is any language that deals with input and output outside the system)?
  22. Is there a way to place some impure code inside pure functions?
  23. How to increment a variable in functional programming?
  24. What part of Hindley-Milner do you not understand?
  25. foldl Implementation with Runtime Errors
  26. Exception handling in Haskell
  27. Haskell Constraint is no smaller than the instance head
  28. Can I match a data constructor wildcard in Haskell?
  29. Is there, in Haskell, something similar to sub-guards?
  30. What is the Comonad typeclass in Haskell?

Leave a Comment