Cache the environment for function definition

This speeds up compilation and reduces memory consumption. For
example, Ecto test suite consumes consistently 30% less memory
and loads 20% faster.

Author: José + Eric

lib/elixir/lib/kernel.ex

@@ -2982,16 +2982,18 @@ defmodule Kernel do
   defp define(kind, call, expr, env) do
     assert_module_scope(env, kind, 2)
     assert_no_function_scope(env, kind, 2)
+    line = env_line(env)
 
     { call, uc } = :elixir_quote.escape(call, true)
     { expr, ue } = :elixir_quote.escape(expr, true)
 
     # Do not check clauses if any expression was unquoted
     check_clauses = not(ue or uc)
+    pos = :elixir_env.cache(env)
 
     quote do
-      :elixir_def.store_definition(unquote(kind), unquote(check_clauses),
-                                   unquote(call), unquote(expr), __ENV__)
+      :elixir_def.store_definition(unquote(line), unquote(kind), unquote(check_clauses),
+                                   unquote(call), unquote(expr), unquote(pos))
     end
   end
 
@@ -3784,6 +3786,7 @@ defmodule Kernel do
   end
 
   defp env_module(env),   do: :erlang.element(2, env)
+  defp env_line(env),     do: :erlang.element(4, env)
   defp env_function(env), do: :erlang.element(5, env)
   defp env_context(env),  do: :erlang.element(6, env)
   defp env_vars(env),     do: :erlang.element(13, env)

lib/elixir/lib/kernel/lexical_tracker.ex

@@ -8,7 +8,7 @@
 # any of the `GenServer.Behaviour` conveniences.
 defmodule Kernel.LexicalTracker do
   @timeout  30_000
-  @behavior :gen_server
+  @behaviour :gen_server
 
   @import 2
   @alias  3
@@ -83,6 +83,16 @@ defmodule Kernel.LexicalTracker do
     unused(pid, @alias)
   end
 
+  @doc false
+  def cache(pid, env) do
+    :gen_server.call(pid, { :cache, env }, @timeout)
+  end
+
+  @doc false
+  def get_cached(pid, ref) do
+    :gen_server.call(pid, { :get_cached, ref }, @timeout)
+  end
+
   defp unused(pid, pos) do
     ets = :gen_server.call(pid, :ets, @timeout)
     :ets.foldl(fn
@@ -97,60 +107,75 @@ defmodule Kernel.LexicalTracker do
 
 
   def init([]) do
-    { :ok, :ets.new(:lexical, [:protected]) }
+    { :ok, { :ets.new(:lexical, [:protected]), [] } }
+  end
+
+  def handle_call({ :cache, env }, _from, { d, cache }) do
+    case cache do
+      [{i,^env}|_] ->
+        { :reply, i, { d, cache } }
+      t ->
+        i = length(t)
+        { :reply, i, { d, [{i,env}|t] } }
+    end
+  end
+
+  def handle_call({ :get_cached, ref }, _from, { _, cache } = state) do
+    { ^ref, env } = :lists.keyfind(ref, 1, cache)
+    { :reply, env, state }
   end
 
-  def handle_call(:ets, _from, d) do
-    { :reply, d, d }
+  def handle_call(:ets, _from, { d, _ } = state) do
+    { :reply, d, state }
   end
 
-  def handle_call(_request, _from, d) do
-    { :noreply, d }
+  def handle_call(_request, _from, state) do
+    { :noreply, state }
   end
 
-  def handle_cast({ :remote_dispatch, module }, d) do
+  def handle_cast({ :remote_dispatch, module }, { d, _ } = state) do
     add_module(d, module)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :import_dispatch, module }, d) do
+  def handle_cast({ :import_dispatch, module }, { d, _ } = state) do
     add_dispatch(d, module, @import)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :alias_dispatch, module }, d) do
+  def handle_cast({ :alias_dispatch, module }, { d, _ } = state) do
     add_dispatch(d, module, @alias)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :add_import, module, line, warn }, d) do
+  def handle_cast({ :add_import, module, line, warn }, { d, _ } = state) do
     add_directive(d, module, line, warn, @import)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast({ :add_alias, module, line, warn }, d) do
+  def handle_cast({ :add_alias, module, line, warn }, { d, _ } = state) do
     add_directive(d, module, line, warn, @alias)
-    { :noreply, d }
+    { :noreply, state }
   end
 
-  def handle_cast(:stop, d) do
-    { :stop, :normal, d }
+  def handle_cast(:stop, state) do
+    { :stop, :normal, state }
   end
 
-  def handle_cast(_msg, d) do
-    { :noreply, d }
+  def handle_cast(_msg, state) do
+    { :noreply, state }
   end
 
-  def handle_info(_msg, d) do
-    { :noreply, d }
+  def handle_info(_msg, state) do
+    { :noreply, state }
   end
 
-  def terminate(_reason, _d) do
+  def terminate(_reason, _state) do
     :ok
   end
 
-  def code_change(_old, d, _extra) do
-    { :ok, d }
+  def code_change(_old, state, _extra) do
+    { :ok, state }
   end
 
   # Callbacks helpers

lib/elixir/src/elixir_bootstrap.erl

@@ -11,12 +11,12 @@
   unless_loaded('MACRO-@', [Caller, Tree], fun() -> nil end).
 
 'MACRO-def'(Caller, Call) -> 'MACRO-def'(Caller, Call, nil).
-'MACRO-def'(Caller, Call, Expr) -> definition(Caller, def, Call, Expr).
-'MACRO-defp'(Caller, Call, Expr) -> definition(Caller, defp, Call, Expr).
+'MACRO-def'(Caller, Call, Expr) -> define(Caller, def, Call, Expr).
+'MACRO-defp'(Caller, Call, Expr) -> define(Caller, defp, Call, Expr).
 
 'MACRO-defmacro'(Caller, Call) -> 'MACRO-defmacro'(Caller, Call, nil).
-'MACRO-defmacro'(Caller, Call, Expr) -> definition(Caller, defmacro, Call, Expr).
-'MACRO-defmacrop'(Caller, Call, Expr) -> definition(Caller, defmacrop, Call, Expr).
+'MACRO-defmacro'(Caller, Call, Expr) -> define(Caller, defmacro, Call, Expr).
+'MACRO-defmacrop'(Caller, Call, Expr) -> define(Caller, defmacrop, Call, Expr).
 
 'MACRO-defmodule'(_Caller, Alias, [{do,Block}]) ->
   { Escaped, _ } = elixir_quote:escape(Block, false),
@@ -35,10 +35,10 @@
    {defmodule,2},
    {defp,2}].
 
-definition(_Caller, Kind, Call, Expr) ->
+define({Line,E}, Kind, Call, Expr) ->
   { EscapedCall, UC } = elixir_quote:escape(Call, true),
   { EscapedExpr, UE } = elixir_quote:escape(Expr, true),
-  Args = [Kind, not(UC or UE), EscapedCall, EscapedExpr, env()],
+  Args = [Line, Kind, not(UC or UE), EscapedCall, EscapedExpr, elixir_env:cache(E)],
   { { '.', [], [elixir_def, store_definition] }, [], Args }.
 
 unless_loaded(Fun, Args, Callback) ->

lib/elixir/src/elixir_def.erl

@@ -2,7 +2,7 @@
 -module(elixir_def).
 -export([table/1, clauses_table/1, setup/1,
   cleanup/1, reset_last/1, lookup_definition/2,
-  delete_definition/2, store_definition/5, unwrap_definitions/2,
+  delete_definition/2, store_definition/6, unwrap_definitions/2,
   store_each/8, format_error/1]).
 -include("elixir.hrl").
 
@@ -48,8 +48,8 @@ delete_definition(Module, Tuple) ->
 % Invoked by the wrap definition with the function abstract tree.
 % Each function is then added to the function table.
 
-store_definition(Kind, CheckClauses, Call, Body, ExEnv) ->
-  #elixir_env{line=Line} = E = elixir_env:ex_to_env(ExEnv),
+store_definition(Line, Kind, CheckClauses, Call, Body, Pos) ->
+  E = (elixir_env:get_cached(Pos))#elixir_env{line=Line},
   { NameAndArgs, Guards } = elixir_clauses:extract_guards(Call),
 
   { Name, Args } = case NameAndArgs of
@@ -76,13 +76,13 @@ store_definition(Kind, CheckClauses, Call, Body, ExEnv) ->
   LinifyBody   = elixir_quote:linify(Line, Key, Body),
 
   assert_no_aliases_name(Line, Name, Args, E),
-  store_definition(Kind, Line, DoCheckClauses, Name,
+  store_definition(Line, Kind, DoCheckClauses, Name,
                    LinifyArgs, LinifyGuards, LinifyBody, File, E).
 
-store_definition(Kind, Line, CheckClauses, Name, Args, Guards, Body, MetaFile, #elixir_env{module=Module} = ER) ->
+store_definition(Line, Kind, CheckClauses, Name, Args, Guards, Body, MetaFile, #elixir_env{module=Module} = ER) ->
   Arity = length(Args),
   Tuple = { Name, Arity },
-  E = ER#elixir_env{function=Tuple,vars=[]},
+  E = ER#elixir_env{function=Tuple},
   elixir_locals:record_definition(Tuple, Kind, Module),
 
   Location = retrieve_file(Line, MetaFile, Module, E),

lib/elixir/src/elixir_env.erl

@@ -1,7 +1,9 @@
 -module(elixir_env).
 -include("elixir.hrl").
 -export([ex_to_env/1, env_to_scope/1, env_to_scope_with_vars/2, env_to_ex/1]).
+-export([cache/1, get_cached/1]).
 -export([mergea/2, mergev/2]).
+-define(tracker, 'Elixir.Kernel.LexicalTracker').
 
 %% Conversion in between #elixir_env, #elixir_scope and Macro.Env
 
@@ -36,3 +38,20 @@ mergev(E1, E2) ->
 
 mergea(E1, E2) ->
   E2#elixir_env{vars=E1#elixir_env.vars}.
+
+%% Caching
+
+cache(#elixir_env{} = RE) ->
+  E = RE#elixir_env{line=nil,vars=[]},
+  case E#elixir_env.lexical_tracker of
+    nil -> escape(E);
+    Pid -> { Pid, ?tracker:cache(Pid, E) }
+  end;
+cache(ExEnv) ->
+  cache(ex_to_env(ExEnv)).
+
+get_cached({Pid,Ref}) -> ?tracker:get_cached(Pid, Ref);
+get_cached(Env) -> Env.
+
+escape(E) ->
+  { Escaped, _ } = elixir_quote:escape(E, false), Escaped.