Efficiency Guide

User's Guide

Version 9.2

• User's Guide
• PDF
• Top

• Expand All
• Contract All

Chapters

• Introduction
  • Top of chapter
  • Purpose
  • Prerequisites
• The Seven Myths of Erlang Performance
  • Top of chapter
  • Myth: Tail-Recursive Functions are Much Faster Than Recursive Functions
  • Myth: Operator "++" is Always Bad
  • Myth: Strings are Slow
  • Myth: Repairing a Dets File is Very Slow
  • Myth: BEAM is a Stack-Based Byte-Code Virtual Machine (and Therefore Slow)
  • Myth: Use "_" to Speed Up Your Program When a Variable is Not Used
  • Myth: A NIF Always Speeds Up Your Program
• Common Caveats
  • Top of chapter
  • Timer Module
  • list_to_atom/1
  • length/1
  • setelement/3
  • size/1
  • split_binary/2
  • Operator "--"
• Constructing and Matching Binaries
  • Top of chapter
  • How Binaries are Implemented
  • Constructing Binaries
  • Matching Binaries
  • Historical Note
• List Handling
  • Top of chapter
  • Creating a List
  • List Comprehensions
  • Deep and Flat Lists
  • Recursive List Functions
• Functions
  • Top of chapter
  • Pattern Matching
  • Function Calls
  • Memory Usage in Recursion
• Tables and Databases
  • Top of chapter
  • Ets, Dets, and Mnesia
  • Ets-Specific
  • Mnesia-Specific
• Processes
  • Top of chapter
  • Creating an Erlang Process
  • Process Messages
  • SMP Emulator
• Drivers
  • Top of chapter
  • Drivers and Concurrency
  • Avoiding Copying Binaries When Calling a Driver
  • Returning Small Binaries from a Driver
  • Returning Large Binaries without Copying from a Driver
• Advanced
  • Top of chapter
  • Memory
  • System Limits
• Profiling
  • Top of chapter
  • Do Not Guess About Performance - Profile
  • Memory profiling
  • Large Systems
  • What to Look For
  • Tools
  • Benchmarking
• Retired Myths
  • Top of chapter
  • Myth: Funs are Slow
  • Myth: List Comprehensions are Slow

2 The Seven Myths of Erlang Performance

Some truths seem to live on well beyond their best-before date, perhaps because "information" spreads faster from person-to-person than a single release note that says, for example, that body-recursive calls have become faster.

This section tries to kill the old truths (or semi-truths) that have become myths.

2.1  Myth: Tail-Recursive Functions are Much Faster Than Recursive Functions

According to the myth, using a tail-recursive function that builds a list in reverse followed by a call to lists:reverse/1 is faster than a body-recursive function that builds the list in correct order; the reason being that body-recursive functions use more memory than tail-recursive functions.

That was true to some extent before R12B. It was even more true before R7B. Today, not so much. A body-recursive function generally uses the same amount of memory as a tail-recursive function. It is generally not possible to predict whether the tail-recursive or the body-recursive version will be faster. Therefore, use the version that makes your code cleaner (hint: it is usually the body-recursive version).

For a more thorough discussion about tail and body recursion, see Erlang's Tail Recursion is Not a Silver Bullet.

2.2  Myth: Operator "++" is Always Bad

The ++ operator has, somewhat undeservedly, got a bad reputation. It probably has something to do with code like the following, which is the most inefficient way there is to reverse a list:

DO NOT

naive_reverse([H|T]) ->
    naive_reverse(T)++[H];
naive_reverse([]) ->
    [].

As the ++ operator copies its left operand, the result is copied repeatedly, leading to quadratic complexity.

But using ++ as follows is not bad:

OK

naive_but_ok_reverse([H|T], Acc) ->
    naive_but_ok_reverse(T, [H]++Acc);
naive_but_ok_reverse([], Acc) ->
    Acc.

Each list element is copied only once. The growing result Acc is the right operand for the ++ operator, and it is not copied.

Experienced Erlang programmers would write as follows:

DO

vanilla_reverse([H|T], Acc) ->
    vanilla_reverse(T, [H|Acc]);
vanilla_reverse([], Acc) ->
    Acc.

This is slightly more efficient because here you do not build a list element only to copy it directly. (Or it would be more efficient if the compiler did not automatically rewrite [H]++Acc to [H|Acc].)

2.3  Myth: Strings are Slow

String handling can be slow if done improperly. In Erlang, you need to think a little more about how the strings are used and choose an appropriate representation. If you use regular expressions, use the re module in STDLIB instead of the obsolete regexp module.

2.4  Myth: Repairing a Dets File is Very Slow

The repair time is still proportional to the number of records in the file, but Dets repairs used to be much slower in the past. Dets has been massively rewritten and improved.

2.5  Myth: BEAM is a Stack-Based Byte-Code Virtual Machine (and Therefore Slow)

BEAM is a register-based virtual machine. It has 1024 virtual registers that are used for holding temporary values and for passing arguments when calling functions. Variables that need to survive a function call are saved to the stack.

BEAM is a threaded-code interpreter. Each instruction is word pointing directly to executable C-code, making instruction dispatching very fast.

2.6  Myth: Use "_" to Speed Up Your Program When a Variable is Not Used

That was once true, but from R6B the BEAM compiler can see that a variable is not used.

Similarly, trivial transformations on the source-code level such as converting a case statement to clauses at the top-level of the function seldom makes any difference to the generated code.

2.7  Myth: A NIF Always Speeds Up Your Program

Rewriting Erlang code to a NIF to make it faster should be seen as a last resort. It is only guaranteed to be dangerous, but not guaranteed to speed up the program.

Doing too much work in each NIF call will degrade responsiveness of the VM. Doing too little work may mean that the gain of the faster processing in the NIF is eaten up by the overhead of calling the NIF and checking the arguments.

Be sure to read about Long-running NIFs before writing a NIF.