Reduce atom footprint when compiling an elixir module

Author: José Valim

lib/elixir/lib/module.ex

@@ -613,11 +613,11 @@ defmodule Module do
   end
 
   defp function_table_for(module) do
-    list_to_atom :lists.concat([:f, module])
+    :elixir_def.table(module)
   end
 
   defp docs_table_for(module) do
-    list_to_atom :lists.concat([:o, module])
+    :elixir_module.docs_table(module)
   end
 
   defp assert_not_compiled!(fun, module) do

lib/elixir/src/elixir_def.erl

@@ -16,18 +16,22 @@
   format_error/1]).
 -include("elixir.hrl").
 
+-define(attr, '__def_table').
+-define(clauses_attr, '__clauses_table').
+
 %% Table management functions. Called internally.
 
-table(Module) -> ?atom_concat([f, Module]).
-clauses_table(Module) -> ?atom_concat([c, Module]).
+table(Module) ->
+  ets:lookup_element(Module, ?attr, 2).
+
+clauses_table(Module) ->
+  ets:lookup_element(Module, ?clauses_attr, 2).
 
 setup(Module) ->
-  FunctionsTable = table(Module),
-  ClausesTable = clauses_table(Module),
-  ets:new(FunctionsTable, [set, named_table, public]),
-  ets:new(ClausesTable, [bag, named_table, public]),
+  ets:insert(Module, { ?attr, ets:new(Module, [set, public]) }),
+  ets:insert(Module, { ?clauses_attr, ets:new(Module, [bag, public]) }),
   reset_last(Module),
-  { FunctionsTable, ClausesTable }.
+  ok.
 
 cleanup(Module) ->
   ets:delete(table(Module)),

lib/elixir/src/elixir_dispatch.erl

@@ -41,7 +41,7 @@ import_function(Meta, Name, Arity, S) ->
     { import, Receiver } ->
       require_function(Meta, Receiver, Name, Arity, S);
     nomatch ->
-      elixir_def_local:record(Tuple, S),
+      elixir_locals:record(Tuple, S),
       { { 'fun', ?line(Meta), { function, Name, Arity } }, S }
   end.
 
@@ -124,7 +124,7 @@ do_expand_import(Meta, { Name, Arity } = Tuple, Args, Module, S, Result) ->
       expand_require(Meta, Receiver, Tuple, Args, Module, S);
     _ ->
       Fun = (S#elixir_scope.function /= Tuple) andalso
-        elixir_def_local:macro_for(Tuple, true, S),
+        elixir_locals:macro_for(Tuple, true, S),
       case Fun of
         false -> { error, noexpansion };
         _ ->
@@ -144,7 +144,7 @@ expand_require(Meta, ?BUILTIN, { Name, Arity } = Tuple, Args, Module, S) ->
 
 expand_require(Meta, Receiver, { Name, Arity } = Tuple, Args, Module, S) ->
   Fun = (Module == Receiver) andalso (S#elixir_scope.function /= Tuple) andalso
-    elixir_def_local:macro_for(Tuple, false, S),
+    elixir_locals:macro_for(Tuple, false, S),
 
   case Fun of
     false ->

lib/elixir/src/elixir_import.erl

@@ -8,6 +8,8 @@
   setup/1, cleanup/1, record/3]).
 -include("elixir.hrl").
 
+-define(attr, '__imports_table').
+
 %% This table keeps:
 %%
 %% * Invoked imports and requires in the format
@@ -16,10 +18,11 @@
 %% * The current warn status imports and requires
 %%   in the format { Module, Line :: integer }
 %%
-table(Module) -> ?atom_concat([i, Module]).
+table(Module) ->
+  ets:lookup_element(Module, ?attr, 2).
 
 setup(Module) ->
-  ets:new(table(Module), [bag, named_table, public]).
+  ets:insert(Module, { ?attr, ets:new(Module, [bag, public]) }).
 
 cleanup(Module) ->
   ets:delete(table(Module)).
@@ -169,8 +172,7 @@ get_optional_macros(Module)  ->
 %% VALIDATION HELPERS
 
 %% Check if any of the locals defined conflicts with an invoked
-%% Elixir "implemented in Erlang" macro. Checking if a local
-%% conflicts with an import is automatically done by Erlang.
+%% Elixir "implemented in Erlang" macro.
 
 ensure_no_local_conflict(Meta, File, Module, AllDefined) ->
   ensure_no_special_form_conflict(Meta, File, Module, AllDefined, local_conflict).

lib/elixir/src/elixir_def_local.erl renamed to lib/elixir/src/elixir_locals.erl

@@ -1,5 +1,5 @@
 %% Module responsible for local invocation of macros and functions.
--module(elixir_def_local).
+-module(elixir_locals).
 -export([
   setup/1, cleanup/1,
   record/2, record_root/2,

lib/elixir/src/elixir_module.erl

@@ -1,8 +1,12 @@
 -module(elixir_module).
--export([translate/4, compile/5, data_table/1, eval_quoted/4,
-         format_error/1, eval_callbacks/5]).
+-export([translate/4, compile/5, data_table/1, docs_table/1,
+         eval_quoted/4, format_error/1, eval_callbacks/5]).
 -include("elixir.hrl").
 
+-define(docs_attr, '__docs_table').
+-define(acc_attr, '__acc_attributes').
+-define(persisted_attr, '__persisted_attributes').
+
 eval_quoted(Module, Quoted, RawBinding, Opts) ->
   Binding = binding_for_eval(Module, RawBinding),
   Scope   = scope_for_eval(Module, Opts),
@@ -31,7 +35,7 @@ data_table(Module) ->
   Module.
 
 docs_table(Module) ->
-  ?atom_concat([o, Module]).
+  ets:lookup_element(Module, ?docs_attr, 2).
 
 %% TRANSFORMATION FUNCTIONS
 
@@ -73,10 +77,10 @@ compile(Line, Module, Block, Vars, #elixir_scope{context_modules=FileModules} =
     case ets:lookup(data_table(Module), 'on_load') of
       [] -> ok;
       [{on_load,OnLoad}] ->
-        [elixir_def_local:record_root(Module, Tuple) || Tuple <- OnLoad]
+        [elixir_locals:record_root(Module, Tuple) || Tuple <- OnLoad]
     end,
 
-    elixir_def_local:check_unused_local(File, Module, Private),
+    elixir_locals:check_unused_local(File, Module, Private),
 
     elixir_import:ensure_all_imports_used(Line, File, Module),
     elixir_import:ensure_no_local_conflict(Line, File, Module, All),
@@ -90,11 +94,11 @@ compile(Line, Module, Block, Vars, #elixir_scope{context_modules=FileModules} =
     Binary = load_form(Line, Final, S),
     { module, Module, Binary, Result }
   after
-    elixir_def_local:cleanup(Module),
-    elixir_def:cleanup(Module),
     elixir_import:cleanup(Module),
-    ets:delete(data_table(Module)),
-    ets:delete(docs_table(Module))
+    elixir_locals:cleanup(Module),
+    elixir_def:cleanup(Module),
+    ets:delete(docs_table(Module)),
+    ets:delete(data_table(Module))
   end;
 
 compile(Line, Other, _Block, _Vars, #elixir_scope{file=File}) ->
@@ -127,17 +131,13 @@ build(Line, File, Module) ->
   end,
 
   Attributes = [behavior, behaviour, on_load, spec, type, export_type, opaque, callback, compile],
-  ets:insert(DataTable, { '__acc_attributes', [before_compile,after_compile,on_definition|Attributes] }),
-  ets:insert(DataTable, { '__persisted_attributes', [vsn|Attributes] }),
-
-  %% Keep docs in another table since we don't want to pull out
-  %% all the binaries every time a new documentation is stored.
-  DocsTable = docs_table(Module),
-  ets:new(DocsTable, [ordered_set, named_table, public]),
+  ets:insert(DataTable, { ?acc_attr, [before_compile,after_compile,on_definition|Attributes] }),
+  ets:insert(DataTable, { ?persisted_attr, [vsn|Attributes] }),
+  ets:insert(DataTable, { ?docs_attr, ets:new(DataTable, [ordered_set, public]) }),
 
   %% Setup other modules
-  elixir_def_local:setup(Module),
   elixir_def:setup(Module),
+  elixir_locals:setup(Module),
   elixir_import:setup(Module).
 
 %% Receives the module representation and evaluates it.

lib/elixir/src/elixir_translator.erl

@@ -578,7 +578,7 @@ translate_fn(Meta, Clauses, S) ->
 %% Locals
 
 translate_local(Meta, Name, Args, #elixir_scope{local=nil} = S) ->
-  elixir_def_local:record({ Name, length(Args) }, S),
+  elixir_locals:record({ Name, length(Args) }, S),
   Line = ?line(Meta),
   { TArgs, NS } = translate_args(Args, S),
   { { call, Line, { atom, Line, Name }, TArgs }, NS };