Merge branch 'sa/dialyzer-parallel' into maint

* sa/dialyzer-parallel: (54 commits)
  Logfile-like statistics (enabled with --resources)
  Anonymous SCCtoPID ETS table
  Anonymous time server
  Regulate all kinds of running workers up to the number of schedulers
  Relocate start and stop of timing server
  Better names for callgaph ETS tables
  Remove needless conversion
  Fix types and specs
  Inline a function in dialyzer_worker
  Remove unused function
  Change --time to --statistics and include more info
  Better reflect side-effect based code in dialyzer_callgraph
  Code simplifications (tidier)
  More efficient calculation of module deps and postorder
  Solve big SCC constraints in parallel
  Coordinator is no longer a separate process
  All spawns are now spawn_links
  Fix race in coordinator
  Typesig and dataflow analyses no longer use ticket regulation
  Plain concatenation for typesig not-fixpoint list
  ...

OTP-10103

1 files changed, 351 insertions, 250 deletions

diff --git a/lib/dialyzer/src/dialyzer_callgraph.erl b/lib/dialyzer/src/dialyzer_callgraph.erl
index effd619bde..64e0ee88af 100644
--- a/lib/dialyzer/src/dialyzer_callgraph.erl
+++ b/lib/dialyzer/src/dialyzer_callgraph.erl
@@ -28,6 +28,7 @@
 -module(dialyzer_callgraph).
 
 -export([add_edges/2,
+	 add_edges/3,
 	 all_nodes/1,
 	 delete/1,
 	 finalize/1,
@@ -43,12 +44,15 @@
 	 %% module_postorder/1,
 	 module_postorder_from_funs/2,
 	 new/0,
+	 get_depends_on/2,
+	 get_required_by/2,
 	 in_neighbours/2,
 	 renew_race_info/4,
+	 renew_race_code/2,
+	 renew_race_public_tables/2,
 	 reset_from_funs/2,
 	 scan_core_tree/2,
 	 strip_module_deps/2,
-	 take_scc/1,
 	 remove_external/1,
 	 to_dot/2,
 	 to_ps/3]).
@@ -57,15 +61,14 @@
          get_race_code/1, get_race_detection/1, race_code_new/1,
          put_digraph/2, put_race_code/2, put_race_detection/2,
          put_named_tables/2, put_public_tables/2, put_behaviour_api_calls/2,
-	 get_behaviour_api_calls/1]).
+	 get_behaviour_api_calls/1, dispose_race_server/1, duplicate/1]).
 
--export_type([callgraph/0, mfa_or_funlbl/0]).
+-export_type([callgraph/0, mfa_or_funlbl/0, callgraph_edge/0]).
 
 -include("dialyzer.hrl").
 
 %%----------------------------------------------------------------------
 
--type mfa_or_funlbl() :: label() | mfa().
 -type scc()	      :: [mfa_or_funlbl()].
 -type mfa_calls()     :: [{mfa_or_funlbl(), mfa_or_funlbl()}].
 
@@ -78,9 +81,6 @@
 %% digraph	-  A digraph representing the callgraph. 
 %%		   Nodes are represented as MFAs or labels.
 %% esc		-  A set of all escaping functions as reported by dialyzer_dep.
-%% postorder	-  A list of strongly connected components of the callgraph
-%%		   sorted in a topological bottom-up order.
-%%		   This is produced by calling finalize/1.
 %% name_map	-  A mapping from label to MFA.
 %% rev_name_map	-  A reverse mapping of the name_map.
 %% rec_var_map	-  A dict mapping from letrec bound labels to function names.
@@ -91,29 +91,42 @@
 %%-----------------------------------------------------------------------------
 
 -record(callgraph, {digraph        = digraph:new() :: digraph(),
-                    esc	           = sets:new()    :: set(),
-                    name_map	   = dict:new()    :: dict(),
-                    rev_name_map   = dict:new()    :: dict(),
-                    postorder      = []	           :: [scc()],
-                    rec_var_map    = dict:new()    :: dict(),
-                    self_rec	   = sets:new()    :: set(),
-                    calls          = dict:new()    :: dict(),
-                    race_code      = dict:new()    :: dict(),
-                    public_tables  = []            :: [label()],
-                    named_tables   = []            :: [string()],
+		    active_digraph                 :: active_digraph(),
+                    esc	                           :: ets:tid(),
+                    name_map	                   :: ets:tid(),
+                    rev_name_map                   :: ets:tid(),
+                    rec_var_map                    :: ets:tid(),
+                    self_rec	                   :: ets:tid(),
+                    calls                          :: ets:tid(),
                     race_detection = false         :: boolean(),
-		    beh_api_calls  = []            :: [{mfa(), mfa()}]}).
+		    race_data_server = new_race_data_server() :: pid()}).
+
+-record(race_data_state, {race_code     = dict:new() :: dict(),
+			  public_tables = []         :: [label()],
+			  named_tables  = []         :: [string()],
+			  beh_api_calls = []         :: [{mfa(), mfa()}]}).
 
 %% Exported Types
 
 -type callgraph() :: #callgraph{}.
 
+-type active_digraph() :: {'d', digraph()} | {'e', ets:tid(), ets:tid()}.
+
 %%----------------------------------------------------------------------
 
 -spec new() -> callgraph().
 
 new() ->
-  #callgraph{}.
+  [ETSEsc, ETSNameMap, ETSRevNameMap, ETSRecVarMap, ETSSelfRec, ETSCalls] =
+    [ets:new(N,[public, {read_concurrency, true}]) ||
+      N <- [callgraph_esc, callgraph_name_map, callgraph_rev_name_map,
+	    callgraph_rec_var_map, callgraph_self_rec, callgraph_calls]],
+  #callgraph{esc            = ETSEsc,
+	     name_map       = ETSNameMap,
+	     rev_name_map   = ETSRevNameMap,
+	     rec_var_map    = ETSRecVarMap,
+	     self_rec       = ETSSelfRec,
+	     calls          = ETSCalls}.
 
 -spec delete(callgraph()) -> 'true'.
 
@@ -129,32 +142,32 @@ all_nodes(#callgraph{digraph = DG}) ->
 
 lookup_rec_var(Label, #callgraph{rec_var_map = RecVarMap}) 
   when is_integer(Label) ->
-  dict:find(Label, RecVarMap).
+  ets_lookup_dict(Label, RecVarMap).
 
 -spec lookup_call_site(label(), callgraph()) -> 'error' | {'ok', [_]}. % XXX: refine
 
 lookup_call_site(Label, #callgraph{calls = Calls})
   when is_integer(Label) ->
-  dict:find(Label, Calls).
+  ets_lookup_dict(Label, Calls).
 
 -spec lookup_name(label(), callgraph()) -> 'error' | {'ok', mfa()}.
 
 lookup_name(Label, #callgraph{name_map = NameMap})
   when is_integer(Label) ->
-  dict:find(Label, NameMap).
+  ets_lookup_dict(Label, NameMap).
 
 -spec lookup_label(mfa_or_funlbl(), callgraph()) -> 'error' | {'ok', integer()}.
 
 lookup_label({_,_,_} = MFA, #callgraph{rev_name_map = RevNameMap}) ->
-  dict:find(MFA, RevNameMap);
+  ets_lookup_dict(MFA, RevNameMap);
 lookup_label(Label, #callgraph{}) when is_integer(Label) ->
   {ok, Label}.
 
 -spec in_neighbours(mfa_or_funlbl(), callgraph()) -> 'none' | [mfa_or_funlbl(),...].
 
-in_neighbours(Label, #callgraph{digraph = Digraph, name_map = NameMap})
+in_neighbours(Label, #callgraph{digraph = Digraph} = CG)
   when is_integer(Label) ->
-  Name = case dict:find(Label, NameMap) of
+  Name = case lookup_name(Label, CG) of
 	   {ok, Val} -> Val;
 	   error -> Label
 	 end,
@@ -165,34 +178,27 @@ in_neighbours({_, _, _} = MFA, #callgraph{digraph = Digraph}) ->
 -spec is_self_rec(mfa_or_funlbl(), callgraph()) -> boolean().
 
 is_self_rec(MfaOrLabel, #callgraph{self_rec = SelfRecs}) ->
-  sets:is_element(MfaOrLabel, SelfRecs).
+  ets_lookup_set(MfaOrLabel, SelfRecs).
 
 -spec is_escaping(label(), callgraph()) -> boolean().
 
 is_escaping(Label, #callgraph{esc = Esc}) when is_integer(Label) ->
-  sets:is_element(Label, Esc).  
+  ets_lookup_set(Label, Esc).
 
 -type callgraph_edge() :: {mfa_or_funlbl(),mfa_or_funlbl()}.
--spec add_edges([callgraph_edge()], callgraph()) -> callgraph().
+-spec add_edges([callgraph_edge()], callgraph()) -> ok.
 
-add_edges([], CG) ->
-  CG;
-add_edges(Edges, #callgraph{digraph = Digraph} = CG) ->
-  CG#callgraph{digraph = digraph_add_edges(Edges, Digraph)}.
+add_edges([], _CG) ->
+  ok;
+add_edges(Edges, #callgraph{digraph = Digraph}) ->
+  digraph_add_edges(Edges, Digraph).
 
--spec add_edges([callgraph_edge()], [mfa_or_funlbl()], callgraph()) -> callgraph().
+-spec add_edges([callgraph_edge()], [mfa_or_funlbl()], callgraph()) -> ok.
 
 add_edges(Edges, MFAs, #callgraph{digraph = DG} = CG) ->
-  DG = digraph_confirm_vertices(MFAs, DG),
+  digraph_confirm_vertices(MFAs, DG),
   add_edges(Edges, CG).
 
--spec take_scc(callgraph()) -> 'none' | {'ok', scc(), callgraph()}.
-
-take_scc(#callgraph{postorder = [SCC|SCCs]} = CG) ->
-  {ok, SCC, CG#callgraph{postorder = SCCs}};
-take_scc(#callgraph{postorder = []}) ->
-  none.
-
 -spec remove_external(callgraph()) -> {callgraph(), [tuple()]}.
 
 remove_external(#callgraph{digraph = DG} = CG) ->
@@ -221,13 +227,25 @@ find_non_local_calls([{Label1, Label2}|Left], Set) when is_integer(Label1),
 find_non_local_calls([], Set) ->
   sets:to_list(Set).
 
--spec renew_race_info(callgraph(), dict(), [label()], [string()]) ->
-        callgraph().
+-spec get_depends_on(scc() | module(), callgraph()) -> [scc()].
+
+get_depends_on(SCC, #callgraph{active_digraph = {'e', Out, _In}}) ->
+  case ets_lookup_dict(SCC, Out) of
+    {ok, Value} -> Value;
+    error -> []
+  end;
+get_depends_on(SCC, #callgraph{active_digraph = {'d', DG}}) ->
+  digraph:out_neighbours(DG, SCC).
+
+-spec get_required_by(scc() | module(), callgraph()) -> [scc()].
 
-renew_race_info(CG, RaceCode, PublicTables, NamedTables) ->
-  CG#callgraph{race_code = RaceCode,
-               public_tables = PublicTables,
-               named_tables = NamedTables}.
+get_required_by(SCC, #callgraph{active_digraph = {'e', _Out, In}}) ->
+  case ets_lookup_dict(SCC, In) of
+    {ok, Value} -> Value;
+    error -> []
+  end;
+get_required_by(SCC, #callgraph{active_digraph = {'d', DG}}) ->
+  digraph:in_neighbours(DG, SCC).
 
 %%----------------------------------------------------------------------
 %% Handling of modules & SCCs
@@ -238,32 +256,37 @@ renew_race_info(CG, RaceCode, PublicTables, NamedTables) ->
 modules(#callgraph{digraph = DG}) ->
   ordsets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]).
 
--spec module_postorder(callgraph()) -> [[module()]].
+-spec module_postorder(callgraph()) -> {[module()], {'d', digraph()}}.
 
 module_postorder(#callgraph{digraph = DG}) ->
-  {MDG, _Nodes} = get_module_digraph_and_nodes(DG),
-  MDG1 = digraph_utils:condensation(MDG),
-  PostOrder = digraph_utils:postorder(MDG1),
-  PostOrder1 = sort_sccs_internally(PostOrder, MDG),
-  digraph:delete(MDG1),
-  digraph_delete(MDG),
-  PostOrder1.
+  Edges = lists:foldl(fun edge_fold/2, sets:new(), digraph_edges(DG)),
+  Nodes = sets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]),
+  MDG = digraph:new([acyclic]),
+  digraph_confirm_vertices(sets:to_list(Nodes), MDG),
+  Foreach = fun({M1,M2}) -> digraph:add_edge(MDG, M1, M2) end,
+  lists:foreach(Foreach, sets:to_list(Edges)),
+  {digraph_utils:topsort(MDG), {'d', MDG}}.
+
+edge_fold({{M1,_,_},{M2,_,_}}, Set) ->
+  case M1 =/= M2 of
+    true  -> sets:add_element({M1,M2},Set);
+    false -> Set
+  end;
+edge_fold(_, Set) -> Set.
 
-get_module_digraph_and_nodes(DG) ->
-  Edges = digraph_edges(DG),
-  Nodes = ordsets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]),
-  MDG = digraph:new(),
-  MDG = digraph_confirm_vertices(Nodes, MDG),
-  MDG = create_module_digraph(Edges, MDG),
-  {MDG, Nodes}.
 
 %% The module deps of a module are modules that depend on the module
 -spec module_deps(callgraph()) -> dict().
 
 module_deps(#callgraph{digraph = DG}) ->
-  {MDG, Nodes} = get_module_digraph_and_nodes(DG),
+  Edges = lists:foldl(fun edge_fold/2, sets:new(), digraph_edges(DG)),
+  Nodes = sets:from_list([M || {M,_F,_A} <- digraph_vertices(DG)]),
+  MDG = digraph:new(),
+  digraph_confirm_vertices(sets:to_list(Nodes), MDG),
+  Foreach = fun({M1,M2}) -> digraph:add_edge(MDG, M1, M2) end,
+  lists:foreach(Foreach, sets:to_list(Edges)),
   Deps = [{N, ordsets:from_list(digraph:in_neighbours(MDG, N))}
-	  || N <- Nodes],
+	  || N <- sets:to_list(Nodes)],
   digraph_delete(MDG),
   dict:from_list(Deps).
 
@@ -276,52 +299,42 @@ strip_module_deps(ModDeps, StripSet) ->
   FilterFun2 = fun(_Key, ValSet) -> ValSet =/= [] end,
   dict:filter(FilterFun2, ModDeps1).
 
-sort_sccs_internally(PO, MDG) ->
-  sort_sccs_internally(PO, MDG, []).
-
-sort_sccs_internally([SCC|SCCs], MDG, Acc) ->
-  case SCC of
-    [_, _, _ | _] ->    % length(SCC) >= 3
-      TmpDG = digraph_utils:subgraph(MDG, SCC),
-      NewSCC = digraph_utils:postorder(TmpDG),
-      digraph_delete(TmpDG),
-      sort_sccs_internally(SCCs, MDG, [NewSCC|Acc]);
-    _ ->
-      sort_sccs_internally(SCCs, MDG, [SCC|Acc])
-  end;
-sort_sccs_internally([], _MDG, Acc) ->
-  lists:reverse(Acc).
-
-create_module_digraph([{{M, _, _}, {M, _, _}}|Left], MDG) ->
-  create_module_digraph(Left, MDG);
-create_module_digraph([{{M1, _, _}, {M2, _, _}}|Left], MDG) ->
-  create_module_digraph(Left, digraph_add_edge(M1, M2, MDG));
-create_module_digraph([{_, _}|Left], MDG) ->
-  create_module_digraph(Left, MDG);
-create_module_digraph([], MDG) ->
-  MDG.
-
--spec finalize(callgraph()) -> callgraph().
+-spec finalize(callgraph()) -> {[scc()], callgraph()}.
 
 finalize(#callgraph{digraph = DG} = CG) ->
-  CG#callgraph{postorder = digraph_finalize(DG)}.
+  {ActiveDG, Postorder} = condensation(DG),
+  {Postorder, CG#callgraph{active_digraph = ActiveDG}}.
 
--spec reset_from_funs([mfa_or_funlbl()], callgraph()) -> callgraph().
+-spec reset_from_funs([mfa_or_funlbl()], callgraph()) -> {[scc()], callgraph()}.
 
-reset_from_funs(Funs, #callgraph{digraph = DG} = CG) ->
+reset_from_funs(Funs, #callgraph{digraph = DG, active_digraph = ADG} = CG) ->
+  active_digraph_delete(ADG),
   SubGraph = digraph_reaching_subgraph(Funs, DG),
-  Postorder = digraph_finalize(SubGraph),
+  {NewActiveDG, Postorder} = condensation(SubGraph),
   digraph_delete(SubGraph),
-  CG#callgraph{postorder = Postorder}.
+  {Postorder, CG#callgraph{active_digraph = NewActiveDG}}.
 
--spec module_postorder_from_funs([mfa_or_funlbl()], callgraph()) -> [[module()]].
+-spec module_postorder_from_funs([mfa_or_funlbl()], callgraph()) ->
+        {[module()], callgraph()}.
 
-module_postorder_from_funs(Funs, #callgraph{digraph = DG} = CG) ->
+module_postorder_from_funs(Funs, #callgraph{digraph = DG,
+					    active_digraph = ADG} = CG) ->
+  active_digraph_delete(ADG),
   SubGraph = digraph_reaching_subgraph(Funs, DG),
-  PO = module_postorder(CG#callgraph{digraph = SubGraph}),
+  {PO, Active} = module_postorder(CG#callgraph{digraph = SubGraph}),
   digraph_delete(SubGraph),
-  PO.
-  
+  {PO, CG#callgraph{active_digraph = Active}}.
+
+ets_lookup_dict(Key, Table) ->
+  try ets:lookup_element(Table, Key, 2) of
+      Val -> {ok, Val}
+  catch
+    _:_ -> error
+  end.
+
+ets_lookup_set(Key, Table) ->
+  ets:lookup(Table, Key) =/= [].
+
 %%----------------------------------------------------------------------
 %% Core code
 %%----------------------------------------------------------------------
@@ -330,36 +343,37 @@ module_postorder_from_funs(Funs, #callgraph{digraph = DG} = CG) ->
 %% The set of labels in the tree must be disjoint from the set of
 %% labels already occuring in the callgraph.
 
--spec scan_core_tree(cerl:c_module(), callgraph()) -> callgraph().
+-spec scan_core_tree(cerl:c_module(), callgraph()) ->
+        {[mfa_or_funlbl()], [callgraph_edge()]}.
 
-scan_core_tree(Tree, #callgraph{calls = OldCalls,
-				esc = OldEsc,
-				name_map = OldNameMap,
-				rec_var_map = OldRecVarMap, 
-				rev_name_map = OldRevNameMap,
-				self_rec = OldSelfRec} = CG) ->
+scan_core_tree(Tree, #callgraph{calls = ETSCalls,
+				esc = ETSEsc,
+				name_map = ETSNameMap,
+				rec_var_map = ETSRecVarMap,
+				rev_name_map = ETSRevNameMap,
+				self_rec = ETSSelfRec}) ->
   %% Build name map and recursion variable maps.
-  {NewNameMap, NewRevNameMap, NewRecVarMap} = 
-    build_maps(Tree, OldRecVarMap, OldNameMap, OldRevNameMap),
-  
+  build_maps(Tree, ETSRecVarMap, ETSNameMap, ETSRevNameMap),
+
   %% First find the module-local dependencies.
   {Deps0, EscapingFuns, Calls} = dialyzer_dep:analyze(Tree),
-  NewCalls = dict:merge(fun(_Key, Val, Val) -> Val end, OldCalls, Calls),
-  NewEsc = sets:union(sets:from_list(EscapingFuns), OldEsc),
+  true = ets:insert(ETSCalls, dict:to_list(Calls)),
+  true = ets:insert(ETSEsc, [{E} || E <- EscapingFuns]),
+
   LabelEdges = get_edges_from_deps(Deps0),
   
   %% Find the self recursive functions. Named functions get both the
   %% key and their name for convenience.
   SelfRecs0 = lists:foldl(fun({Key, Key}, Acc) -> 
-			      case dict:find(Key, NewNameMap) of
+			      case ets_lookup_dict(Key, ETSNameMap) of
 				error      -> [Key|Acc];
 				{ok, Name} -> [Key, Name|Acc]
 			      end;
 			     (_, Acc) -> Acc
 			  end, [], LabelEdges),
-  SelfRecs = sets:union(sets:from_list(SelfRecs0), OldSelfRec),
+  true = ets:insert(ETSSelfRec, [{S} || S <- SelfRecs0]),
   
-  NamedEdges1 = name_edges(LabelEdges, NewNameMap),
+  NamedEdges1 = name_edges(LabelEdges, ETSNameMap),
   
   %% We need to scan for inter-module calls since these are not tracked
   %% by dialyzer_dep. Note that the caller is always recorded as the
@@ -378,27 +392,25 @@ scan_core_tree(Tree, #callgraph{calls = OldCalls,
   NewNamedEdges1 =
     [E || {From, To} = E <- NamedEdges1, From =/= top, To =/= top],
   NamedEdges3 = NewNamedEdges1 ++ NewNamedEdges2,
-  CG1 = add_edges(NamedEdges3, Names3, CG),
-  CG1#callgraph{calls = NewCalls,
-                esc = NewEsc,
-                name_map = NewNameMap,
-                rec_var_map = NewRecVarMap, 
-                rev_name_map = NewRevNameMap,
-                self_rec = SelfRecs}.
-
-build_maps(Tree, RecVarMap, NameMap, RevNameMap) ->
+  {Names3, NamedEdges3}.
+
+build_maps(Tree, ETSRecVarMap, ETSNameMap, ETSRevNameMap) ->
   %% We only care about the named (top level) functions. The anonymous
   %% functions will be analysed together with their parents. 
   Defs = cerl:module_defs(Tree),
   Mod = cerl:atom_val(cerl:module_name(Tree)),
-  lists:foldl(fun({Var, Function}, {AccNameMap, AccRevNameMap, AccRecVarMap}) ->
-		  FunName = cerl:fname_id(Var),
-		  Arity = cerl:fname_arity(Var),
-		  MFA = {Mod, FunName, Arity},
-		  {dict:store(get_label(Function), MFA, AccNameMap),
-		   dict:store(MFA, get_label(Function), AccRevNameMap),
-		   dict:store(get_label(Var), MFA, AccRecVarMap)}
-	      end, {NameMap, RevNameMap, RecVarMap}, Defs).
+  Fun =
+    fun({Var, Function}) ->
+	FunName = cerl:fname_id(Var),
+	Arity = cerl:fname_arity(Var),
+	MFA = {Mod, FunName, Arity},
+	FunLabel = get_label(Function),
+	VarLabel = get_label(Var),
+	true = ets:insert(ETSNameMap, {FunLabel, MFA}),
+	true = ets:insert(ETSRevNameMap, {MFA, FunLabel}),
+	true = ets:insert(ETSRecVarMap, {VarLabel, MFA})
+    end,
+  lists:foreach(Fun, Defs).
 
 get_edges_from_deps(Deps) ->
   %% Convert the dependencies as produced by dialyzer_dep to a list of
@@ -411,22 +423,22 @@ get_edges_from_deps(Deps) ->
 		    end, [], Deps),
   lists:flatten(Edges).
 
-name_edges(Edges, NameMap) ->
+name_edges(Edges, ETSNameMap) ->
   %% If a label is present in the name map it is renamed. Otherwise
   %% keep the label as the identity.
   MapFun = fun(X) ->
-	       case dict:find(X, NameMap) of
+	       case ets_lookup_dict(X, ETSNameMap) of
 		 error -> X;
 		 {ok, MFA} -> MFA
 	       end
 	   end,
-  name_edges(Edges, MapFun, NameMap, []).
+  name_edges(Edges, MapFun, []).
 
-name_edges([{From, To}|Left], MapFun, NameMap, Acc) ->
+name_edges([{From, To}|Left], MapFun, Acc) ->
   NewFrom = MapFun(From),
   NewTo = MapFun(To),
-  name_edges(Left, MapFun, NameMap, [{NewFrom, NewTo}|Acc]);
-name_edges([], _MapFun, _NameMap, Acc) ->
+  name_edges(Left, MapFun, [{NewFrom, NewTo}|Acc]);
+name_edges([], _MapFun, Acc) ->
   Acc.
 
 scan_core_funs(Tree) ->
@@ -478,9 +490,10 @@ get_label(T) ->
 %%----------------------------------------------------------------------
 
 digraph_add_edges([{From, To}|Left], DG) ->
-  digraph_add_edges(Left, digraph_add_edge(From, To, DG));
-digraph_add_edges([], DG) ->
-  DG.
+  digraph_add_edge(From, To, DG),
+  digraph_add_edges(Left, DG);
+digraph_add_edges([], _DG) ->
+  ok.
 
 digraph_add_edge(From, To, DG) ->
   case digraph:vertex(DG, From) of
@@ -492,13 +505,13 @@ digraph_add_edge(From, To, DG) ->
     {To, _} -> ok
   end,
   digraph:add_edge(DG, {From, To}, From, To, []),
-  DG.
+  ok.
 
 digraph_confirm_vertices([MFA|Left], DG) ->
   digraph:add_vertex(DG, MFA, confirmed),
   digraph_confirm_vertices(Left, DG);
-digraph_confirm_vertices([], DG) ->
-  DG.
+digraph_confirm_vertices([], _DG) ->
+  ok.
   
 digraph_remove_external(DG) ->
   Vertices = digraph:vertices(DG),
@@ -522,6 +535,12 @@ remove_unconfirmed([], DG, Unconfirmed) ->
 digraph_delete(DG) ->
   digraph:delete(DG).
 
+active_digraph_delete({'d', DG}) ->
+  digraph:delete(DG);
+active_digraph_delete({'e', Out, In}) ->
+  ets:delete(Out),
+  ets:delete(In).
+
 digraph_edges(DG) ->
   digraph:edges(DG).
 
@@ -534,75 +553,6 @@ digraph_in_neighbours(V, DG) ->
     List -> List
   end.
 
-%% Pick all the independent nodes (leaves) from one module. Then try
-%% to stay within the module until no more independent nodes can be
-%% chosen. Then pick a new module and so on.
-%%
-%% Note that an SCC that ranges over more than one module is
-%% considered to belong to all modules to make sure that we do not
-%% lose any nodes.
-
-digraph_postorder(Digraph) ->
-  %% Remove all self-edges for SCCs.
-  Edges = [digraph:edge(Digraph, E) || E <- digraph:edges(Digraph)],
-  SelfEdges = [E || {E, V, V, _} <- Edges],
-  true = digraph:del_edges(Digraph, SelfEdges),
-  %% Determine the first module outside of the loop.
-  Leaves = digraph_leaves(Digraph),
-  case Leaves =:= [] of
-    true -> [];
-    false ->
-      {Module, Taken} = take_sccs_from_fresh_module(Leaves),
-      true = digraph:del_vertices(Digraph, Taken),
-      digraph_postorder(Digraph, Module, [Taken])
-  end.
-
-digraph_postorder(Digraph, LastModule, Acc) ->
-  Leaves = digraph_leaves(Digraph),
-  case Leaves =:= [] of
-    true -> lists:append(lists:reverse(Acc));
-    false ->
-      case [SCC || SCC <- Leaves, scc_belongs_to_module(SCC, LastModule)] of
-	[] ->
-	  {NewModule, NewTaken} = take_sccs_from_fresh_module(Leaves),
-	  true = digraph:del_vertices(Digraph, NewTaken),
-	  digraph_postorder(Digraph, NewModule, [NewTaken|Acc]);
-	NewTaken ->
-	  true = digraph:del_vertices(Digraph, NewTaken),
-	  digraph_postorder(Digraph, LastModule, [NewTaken|Acc])
-      end
-  end.
-
-digraph_leaves(Digraph) ->
-  [V || V <- digraph:vertices(Digraph), digraph:out_degree(Digraph, V) =:= 0].
-
-take_sccs_from_fresh_module(Leaves) ->
-  NewModule = find_module(hd(Leaves)),
-  {NewModule, 
-   [SCC || SCC <- Leaves, scc_belongs_to_module(SCC, NewModule)]}.
-
--spec scc_belongs_to_module(scc(), module()) -> boolean().
-
-scc_belongs_to_module([Label|Left], Module) when is_integer(Label) ->
-  scc_belongs_to_module(Left, Module);
-scc_belongs_to_module([{M, _, _}|Left], Module) ->
-  if M =:= Module -> true;
-     true -> scc_belongs_to_module(Left, Module)
-  end;
-scc_belongs_to_module([], _Module) ->
-  false.
-      
--spec find_module(scc()) -> module().
-
-find_module([{M, _, _}|_]) -> M;
-find_module([Label|Left]) when is_integer(Label) -> find_module(Left).
-
-digraph_finalize(DG) ->
-  DG1 = digraph_utils:condensation(DG),
-  Postorder = digraph_postorder(DG1),
-  digraph:delete(DG1),
-  Postorder.
-
 digraph_reaching_subgraph(Funs, DG) ->  
   Vertices = digraph_utils:reaching(Funs, DG),
   digraph_utils:subgraph(DG, Vertices).
@@ -611,20 +561,71 @@ digraph_reaching_subgraph(Funs, DG) ->
 %% Races
 %%----------------------------------------------------------------------
 
+-spec renew_race_info(callgraph(), dict(), [label()], [string()]) ->
+        callgraph().
+
+renew_race_info(#callgraph{race_data_server = RaceDataServer} = CG,
+		RaceCode, PublicTables, NamedTables) ->
+  ok = race_data_server_cast(
+	 {renew_race_info, {RaceCode, PublicTables, NamedTables}},
+	 RaceDataServer),
+  CG.
+
+renew_race_info({RaceCode, PublicTables, NamedTables},
+		#race_data_state{} = State) ->
+  State#race_data_state{race_code = RaceCode,
+			public_tables = PublicTables,
+			named_tables = NamedTables}.
+
+-spec renew_race_code(dialyzer_races:races(), callgraph()) -> callgraph().
+
+renew_race_code(Races, #callgraph{race_data_server = RaceDataServer} = CG) ->
+  Fun = dialyzer_races:get_curr_fun(Races),
+  FunArgs = dialyzer_races:get_curr_fun_args(Races),
+  Code = lists:reverse(dialyzer_races:get_race_list(Races)),
+  ok = race_data_server_cast(
+	 {renew_race_code, {Fun, FunArgs, Code}},
+	 RaceDataServer),
+  CG.
+
+renew_race_code_handler({Fun, FunArgs, Code},
+		      #race_data_state{race_code = RaceCode} = State) ->
+  State#race_data_state{race_code = dict:store(Fun, [FunArgs, Code], RaceCode)}.
+
+-spec renew_race_public_tables(label(), callgraph()) -> callgraph().
+
+renew_race_public_tables(VarLabel,
+			 #callgraph{race_data_server = RaceDataServer} = CG) ->
+  ok =
+    race_data_server_cast({renew_race_public_tables, VarLabel}, RaceDataServer),
+  CG.
+
+renew_race_public_tables_handler(VarLabel,
+				 #race_data_state{public_tables = PT}
+				 = State) ->
+  State#race_data_state{public_tables = ordsets:add_element(VarLabel, PT)}.
+
 -spec cleanup(callgraph()) -> callgraph().
 
-cleanup(#callgraph{digraph = Digraph,                                          
-                   name_map = NameMap,                                         
-                   rev_name_map = RevNameMap,                                  
-                   public_tables = PublicTables,                               
-                   named_tables = NamedTables,                                 
-                   race_code = RaceCode}) ->                                   
+cleanup(#callgraph{digraph = Digraph,
+                   name_map = NameMap,
+                   rev_name_map = RevNameMap,
+		   race_data_server = RaceDataServer}) ->
   #callgraph{digraph = Digraph,
-             name_map = NameMap,                                          
-             rev_name_map = RevNameMap,                                   
-             public_tables = PublicTables,                                
-             named_tables = NamedTables,                                  
-             race_code = RaceCode}.
+	     name_map = NameMap,
+             rev_name_map = RevNameMap,
+	     race_data_server = race_data_server_call(dup, RaceDataServer)}.
+
+-spec duplicate(callgraph()) -> callgraph().
+
+duplicate(#callgraph{race_data_server = RaceDataServer} = Callgraph) ->
+  Callgraph#callgraph{
+    race_data_server = race_data_server_call(dup, RaceDataServer)}.
+
+-spec dispose_race_server(callgraph()) -> ok.
+
+dispose_race_server(#callgraph{race_data_server = RaceDataServer}) ->
+  race_data_server_cast(stop, RaceDataServer).
 
 -spec get_digraph(callgraph()) -> digraph().
 
@@ -633,28 +634,34 @@ get_digraph(#callgraph{digraph = Digraph}) ->
 
 -spec get_named_tables(callgraph()) -> [string()].
 
-get_named_tables(#callgraph{named_tables = NamedTables}) ->
-  NamedTables.
+get_named_tables(#callgraph{race_data_server = RaceDataServer}) ->
+  race_data_server_call(get_named_tables, RaceDataServer).
 
 -spec get_public_tables(callgraph()) -> [label()].
 
-get_public_tables(#callgraph{public_tables = PT}) ->
-  PT.
+get_public_tables(#callgraph{race_data_server = RaceDataServer}) ->
+  race_data_server_call(get_public_tables, RaceDataServer).
 
 -spec get_race_code(callgraph()) -> dict().
 
-get_race_code(#callgraph{race_code = RaceCode}) ->
-  RaceCode.
+get_race_code(#callgraph{race_data_server = RaceDataServer}) ->
+  race_data_server_call(get_race_code, RaceDataServer).
 
 -spec get_race_detection(callgraph()) -> boolean().
 
 get_race_detection(#callgraph{race_detection = RD}) ->
   RD.
 
+-spec get_behaviour_api_calls(callgraph()) -> [{mfa(), mfa()}].
+
+get_behaviour_api_calls(#callgraph{race_data_server = RaceDataServer}) ->
+  race_data_server_call(get_behaviour_api_calls, RaceDataServer).
+
 -spec race_code_new(callgraph()) -> callgraph().
 
-race_code_new(Callgraph) ->
-  Callgraph#callgraph{race_code = dict:new()}.
+race_code_new(#callgraph{race_data_server = RaceDataServer} = CG) ->
+  ok = race_data_server_cast(race_code_new, RaceDataServer),
+  CG.
 
 -spec put_digraph(digraph(), callgraph()) -> callgraph().
 
@@ -663,8 +670,9 @@ put_digraph(Digraph, Callgraph) ->
 
 -spec put_race_code(dict(), callgraph()) -> callgraph().
 
-put_race_code(RaceCode, Callgraph) ->
-  Callgraph#callgraph{race_code = RaceCode}.
+put_race_code(RaceCode, #callgraph{race_data_server = RaceDataServer} = CG) ->
+  ok = race_data_server_cast({put_race_code, RaceCode}, RaceDataServer),
+  CG.
 
 -spec put_race_detection(boolean(), callgraph()) -> callgraph().
 
@@ -673,13 +681,79 @@ put_race_detection(RaceDetection, Callgraph) ->
 
 -spec put_named_tables([string()], callgraph()) -> callgraph().
 
-put_named_tables(NamedTables, Callgraph) ->
-  Callgraph#callgraph{named_tables = NamedTables}.
+put_named_tables(NamedTables,
+		 #callgraph{race_data_server = RaceDataServer} = CG) ->
+  ok = race_data_server_cast({put_named_tables, NamedTables}, RaceDataServer),
+  CG.
 
 -spec put_public_tables([label()], callgraph()) -> callgraph().
 
-put_public_tables(PublicTables, Callgraph) ->
-  Callgraph#callgraph{public_tables = PublicTables}.
+put_public_tables(PublicTables,
+		 #callgraph{race_data_server = RaceDataServer} = CG) ->
+  ok = race_data_server_cast({put_public_tables, PublicTables}, RaceDataServer),
+  CG.
+
+-spec put_behaviour_api_calls([{mfa(), mfa()}], callgraph()) -> callgraph().
+
+put_behaviour_api_calls(Calls,
+		 #callgraph{race_data_server = RaceDataServer} = CG) ->
+  ok = race_data_server_cast({put_behaviour_api_calls, Calls}, RaceDataServer),
+  CG.
+
+
+new_race_data_server() ->
+  spawn_link(fun() -> race_data_server_loop(#race_data_state{}) end).
+
+race_data_server_loop(State) ->
+  receive
+    {call, From, Ref, Query} ->
+      Reply = race_data_server_handle_call(Query, State),
+      From ! {Ref, Reply},
+      race_data_server_loop(State);
+    {cast, stop} ->
+      ok;
+    {cast, Message} ->
+      NewState = race_data_server_handle_cast(Message, State),
+      race_data_server_loop(NewState)
+  end.
+
+race_data_server_call(Query, Server) ->
+  Ref = make_ref(),
+  Server ! {call, self(), Ref, Query},
+  receive
+    {Ref, Reply} -> Reply
+  end.
+
+race_data_server_cast(Message, Server) ->
+  Server ! {cast, Message},
+  ok.
+
+race_data_server_handle_cast(race_code_new, State) ->
+  State#race_data_state{race_code = dict:new()};
+race_data_server_handle_cast({Tag, Data}, State) ->
+  case Tag of
+    renew_race_info -> renew_race_info(Data, State);
+    renew_race_code -> renew_race_code_handler(Data, State);
+    renew_race_public_tables -> renew_race_public_tables_handler(Data, State);
+    put_race_code -> State#race_data_state{race_code = Data};
+    put_public_tables -> State#race_data_state{public_tables = Data};
+    put_named_tables -> State#race_data_state{named_tables = Data};
+    put_behaviour_api_calls -> State#race_data_state{beh_api_calls = Data}
+  end.
+
+race_data_server_handle_call(Query,
+			     #race_data_state{race_code = RaceCode,
+					      public_tables = PublicTables,
+					      named_tables = NamedTables,
+					      beh_api_calls = BehApiCalls}
+			     = State) ->
+  case Query of
+    dup -> spawn_link(fun() -> race_data_server_loop(State) end);
+    get_race_code -> RaceCode;
+    get_public_tables -> PublicTables;
+    get_named_tables -> NamedTables;
+    get_behaviour_api_calls -> BehApiCalls
+  end.
 
 %%=============================================================================
 %% Utilities for 'dot'
@@ -695,7 +769,7 @@ to_dot(#callgraph{digraph = DG, esc = Esc} = CG, File) ->
 	    end
 	end,
   Escaping = [{Fun(L), {color, red}} 
-	      || L <- sets:to_list(Esc), L =/= external],
+	      || L <- [E || {E} <- ets:tab2list(Esc)], L =/= external],
   Vertices = digraph_edges(DG),
   hipe_dot:translate_list(Vertices, File, "CG", Escaping).
 
@@ -708,14 +782,41 @@ to_ps(#callgraph{} = CG, File, Args) ->
   _ = os:cmd(Command),
   ok.
 
-%-------------------------------------------------------------------------------
-
--spec put_behaviour_api_calls([{mfa(), mfa()}], callgraph()) -> callgraph().
-
-put_behaviour_api_calls(Calls, Callgraph) ->
-  Callgraph#callgraph{beh_api_calls = Calls}.
-
--spec get_behaviour_api_calls(callgraph()) -> [{mfa(), mfa()}].
-
-get_behaviour_api_calls(Callgraph) ->
-  Callgraph#callgraph.beh_api_calls.
+condensation(G) ->
+  SCs = digraph_utils:strong_components(G),
+  V2I = ets:new(condensation_v2i, []),
+  I2C = ets:new(condensation_i2c, []),
+  I2I = ets:new(condensation_i2i, [bag]),
+  CFun =
+    fun(SC, N) ->
+	lists:foreach(fun(V) -> true = ets:insert(V2I, {V,N}) end, SC),
+	true = ets:insert(I2C, {N, SC}),
+	N + 1
+    end,
+  lists:foldl(CFun, 1, SCs),
+  Fun1 =
+    fun({V1, V2}) ->
+        I1 = ets:lookup_element(V2I, V1, 2),
+        I2 = ets:lookup_element(V2I, V2, 2),
+	case I1 =:= I2 of
+	  true  -> true;
+	  false -> ets:insert(I2I, {I1, I2})
+	end
+    end,
+  lists:foreach(Fun1, digraph:edges(G)),
+  Fun3 =
+    fun({I1, I2}, {Out, In}) ->
+        SC1 = ets:lookup_element(I2C, I1, 2),
+        SC2 = ets:lookup_element(I2C, I2, 2),
+        {dict:append(SC1, SC2, Out), dict:append(SC2, SC1, In)}
+    end,
+  {OutDict, InDict} = ets:foldl(Fun3, {dict:new(), dict:new()}, I2I),
+  [OutETS, InETS] =
+    [ets:new(Name,[{read_concurrency, true}]) ||
+      Name <- [callgraph_deps_out, callgraph_deps_in]],
+  ets:insert(OutETS, dict:to_list(OutDict)),
+  ets:insert(InETS, dict:to_list(InDict)),
+  ets:delete(V2I),
+  ets:delete(I2C),
+  ets:delete(I2I),
+  {{'e', OutETS, InETS}, SCs}.