path: root/system/doc/efficiency_guide/functions.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE chapter SYSTEM "chapter.dtd">

<chapter>
  <header>
    <copyright>
      <year>2001</year><year>2016</year>
      <holder>Ericsson AB. All Rights Reserved.</holder>
    </copyright>
    <legalnotice>
      Licensed under the Apache License, Version 2.0 (the "License");
      you may not use this file except in compliance with the License.
      You may obtain a copy of the License at
 
          http://www.apache.org/licenses/LICENSE-2.0

      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.
    </legalnotice>

    <title>Functions</title>
    <prepared>Bjorn Gustavsson</prepared>
    <docno></docno>
    <date>2007-11-22</date>
    <rev></rev>
    <file>functions.xml</file>
  </header>

  <section>
    <title>Pattern Matching</title>
    <p>Pattern matching in function head as well as in <c>case</c> and
    <c>receive</c> clauses are optimized by the compiler. With a few
    exceptions, there is nothing to gain by rearranging clauses.</p>

    <p>One exception is pattern matching of binaries. The compiler
    does not rearrange clauses that match binaries. Placing the
    clause that matches against the empty binary <em>last</em> is usually
    slightly faster than placing it <em>first</em>.</p>

    <p>The following is a rather unnatural example to show another
    exception:</p>

    <p><em>DO NOT</em></p>
    <code type="erl">
atom_map1(one) -> 1;
atom_map1(two) -> 2;
atom_map1(three) -> 3;
atom_map1(Int) when is_integer(Int) -> Int;
atom_map1(four) -> 4;
atom_map1(five) -> 5;
atom_map1(six) -> 6.</code>

     <p>The problem is the clause with the variable <c>Int</c>.
     As a variable can match anything, including the atoms
     <c>four</c>, <c>five</c>, and <c>six</c>, which the following clauses
     also match, the compiler must generate suboptimal code that
     executes as follows:</p>

     <list type="bulleted">
     <item>First, the input value is compared to <c>one</c>, <c>two</c>, and
     <c>three</c> (using a single instruction that does a binary search;
     thus, quite efficient even if there are many values) to select which
     one of the first three clauses to execute (if any).</item>

     <item>>If none of the first three clauses match, the fourth clause
     match as a variable always matches.</item>

     <item>If the guard test <c>is_integer(Int)</c> succeeds, the fourth
     clause is executed.</item>

     <item>If the guard test fails, the input value is compared to
     <c>four</c>, <c>five</c>, and <c>six</c>, and the appropriate clause
     is selected. (There is a <c>function_clause</c> exception if none of
     the values matched.)</item>
     </list>

     <p>Rewriting to either:</p>

     <p><em>DO</em></p>
     <code type="erl"><![CDATA[
atom_map2(one) -> 1;
atom_map2(two) -> 2;
atom_map2(three) -> 3;
atom_map2(four) -> 4;
atom_map2(five) -> 5;
atom_map2(six) -> 6;
atom_map2(Int) when is_integer(Int) -> Int.]]></code>

     <p>or:</p>

     <p><em>DO</em></p>
     <code type="erl"><![CDATA[
atom_map3(Int) when is_integer(Int) -> Int;
atom_map3(one) -> 1;
atom_map3(two) -> 2;
atom_map3(three) -> 3;
atom_map3(four) -> 4;
atom_map3(five) -> 5;
atom_map3(six) -> 6.]]></code>

     <p>gives slightly more efficient matching code.</p>

     <p>Another example:</p>

     <p><em>DO NOT</em></p>
     <code type="erl"><![CDATA[
map_pairs1(_Map, [], Ys) ->
    Ys;
map_pairs1(_Map, Xs, [] ) ->
    Xs;
map_pairs1(Map, [X|Xs], [Y|Ys]) ->
    [Map(X, Y)|map_pairs1(Map, Xs, Ys)].]]></code>

     <p>The first argument is <em>not</em> a problem. It is variable, but it
     is a variable in all clauses. The problem is the variable in the second
     argument, <c>Xs</c>, in the middle clause. Because the variable can
     match anything, the compiler is not allowed to rearrange the clauses,
     but must generate code that matches them in the order written.</p>

     <p>If the function is rewritten as follows, the compiler is free to
     rearrange the clauses:</p>

     <p><em>DO</em></p>
     <code type="erl"><![CDATA[
map_pairs2(_Map, [], Ys) ->
    Ys;
map_pairs2(_Map, [_|_]=Xs, [] ) ->
    Xs;
map_pairs2(Map, [X|Xs], [Y|Ys]) ->
    [Map(X, Y)|map_pairs2(Map, Xs, Ys)].]]></code>

    <p>The compiler will generate code similar to this:</p>

    <p><em>DO NOT (already done by the compiler)</em></p>
    <code type="erl"><![CDATA[
explicit_map_pairs(Map, Xs0, Ys0) ->
    case Xs0 of
	[X|Xs] ->
	    case Ys0 of
		[Y|Ys] ->
		    [Map(X, Y)|explicit_map_pairs(Map, Xs, Ys)];
		[] ->
		    Xs0
	    end;
	[] ->
	    Ys0
    end.]]></code>
      
    <p>This is slightly faster for probably the most common case
    that the input lists are not empty or very short.
    (Another advantage is that Dialyzer can deduce a better type
    for the <c>Xs</c> variable.)</p>
  </section>

  <section>
    <title>Function Calls</title>

    <p>This is an intentionally rough guide to the relative costs of
    different calls. It is based on benchmark figures run on
    Solaris/Sparc:</p>

    <list type="bulleted">
    <item>Calls to local or external functions (<c>foo()</c>, <c>m:foo()</c>)
    are the fastest calls.</item>

    <item>Calling or applying a fun (<c>Fun()</c>, <c>apply(Fun, [])</c>)
    is about <em>three times</em> as expensive as calling a local
    function.</item>

    <item>Applying an exported function (<c>Mod:Name()</c>,
    <c>apply(Mod, Name, [])</c>) is about twice as expensive as calling
    a fun or about <em>six times</em> as expensive as calling a local
    function.</item>
    </list>

    <section>
       <title>Notes and Implementation Details</title>

       <p>Calling and applying a fun does not involve any hash-table lookup.
       A fun contains an (indirect) pointer to the function that implements
       the fun.</p>

       <warning><p><em>Tuples are not fun(s)</em>.
       A "tuple fun", <c>{Module,Function}</c>, is not a fun.
       The cost for calling a "tuple fun" is similar to that
       of <c>apply/3</c> or worse.
       Using "tuple funs" is <em>strongly discouraged</em>,
       as they might not be supported in a future Erlang/OTP release,
       and because there exists a superior alternative from R10B,
       namely the <c>fun Module:Function/Arity</c> syntax.</p></warning>

       <p><c>apply/3</c> must look up the code for the function to execute
       in a hash table. It is therefore always slower than a
       direct call or a fun call.</p>

       <p>It no longer matters (from a performance point of view)
       whether you write:</p>

       <code type="erl">
Module:Function(Arg1, Arg2)</code>

       <p>or:</p>

       <code type="erl">
apply(Module, Function, [Arg1,Arg2])</code>

       <p>The compiler internally rewrites the latter code into the
       former.</p>

       <p>The following code is slightly slower because the shape of the
       list of arguments is unknown at compile time.</p>

       <code type="erl">
apply(Module, Function, Arguments)</code>

    </section>
  </section>

  <section>
    <title>Memory Usage in Recursion</title>
    <p>When writing recursive functions, it is preferable to make them
      tail-recursive so that they can execute in constant memory space:</p>

    <p><em>DO</em></p>
    <code type="none">
list_length(List) ->
    list_length(List, 0).

list_length([], AccLen) -> 
    AccLen; % Base case

list_length([_|Tail], AccLen) ->
    list_length(Tail, AccLen + 1). % Tail-recursive</code>

    <p><em>DO NOT</em></p>

    <code type="none">
list_length([]) ->
    0. % Base case
list_length([_ | Tail]) ->
    list_length(Tail) + 1. % Not tail-recursive</code>
  </section>
</chapter>