do not duplicate child specs in different syn scopes

to decrease memory usage in ets, do not track twice the child specs in
different scopes. This especially helps if the start data passed to
start link is big

Author: flaviogrossi

lib/syn_supervisor.ex

@@ -784,9 +784,11 @@ defmodule SynSupervisor do
     reply =
       state.scope
       |> Distribution.list_children()
-      |> Enum.map(fn %Child{} = c ->
-        {id, _, _, _, type, modules} = c.spec
-        {id, c.pid, type, modules}
+      |> Enum.flat_map(fn %Child{} = c ->
+        case Distribution.spec_for_child(state.scope, c) do
+          {:ok, {id, _, _, _, type, modules}} -> [{id, c.pid, type, modules}]
+          _ -> []
+        end
       end)
 
     {:reply, reply, state}
@@ -832,9 +834,10 @@ defmodule SynSupervisor do
     {active, workers, supervisors} =
       Enum.reduce(children, {0, 0, 0}, fn
         %Child{} = c, {active, worker, supervisor} ->
-          case c.spec do
-            {_, _, _, _, :worker, _} -> {active + 1, worker + 1, supervisor}
-            {_, _, _, _, :supervisor, _} -> {active + 1, worker, supervisor + 1}
+          case Distribution.spec_for_child(state.scope, c) do
+            {:ok, {_, _, _, _, :worker, _}} -> {active + 1, worker + 1, supervisor}
+            {:ok, {_, _, _, _, :supervisor, _}} -> {active + 1, worker, supervisor + 1}
+            _ -> {active, worker, supervisor}
           end
       end)
 
@@ -854,10 +857,9 @@ defmodule SynSupervisor do
         # try local children anyway
         terminate_local_children(pid_or_child_id, state)
 
-      {:ok, %Child{node: node, supervisor_pid: supervisor} = c} ->
+      {:ok, %Child{id: child_id, node: node, supervisor_pid: supervisor} = c} ->
         if node == Node.self() do
-          Distribution.untrack_spec(state.scope, c.spec)
-          terminate_local_children(c.pid, state)
+          terminate_local_children_and_untrack_spec(c.pid, child_id, state)
         else
           terminate_remote_children(node, supervisor, c.pid, state)
         end
@@ -876,6 +878,17 @@ defmodule SynSupervisor do
     end
   end
 
+  defp terminate_local_children_and_untrack_spec(pid, child_id, state) do
+    case terminate_local_children(pid, state) do
+      {:reply, :ok, next_state} ->
+        Distribution.untrack_spec(state.scope, child_id)
+        {:reply, :ok, next_state}
+
+      reply ->
+        reply
+    end
+  end
+
   defp terminate_local_children(pid, %{children: children} = state) when is_pid(pid) do
     case children do
       %{^pid => info} ->
@@ -1170,13 +1183,23 @@ defmodule SynSupervisor do
 
   defp maybe_start_child(%Child{} = c, assigned_node, _assigned_sup, state) do
     if assigned_node == Node.self() and c.node != Node.self() do
-      {_, _, state} = start_local_child(c.spec, state)
-      state
+      find_spec_and_start_local_child(c.id, state)
     else
       state
     end
   end
 
+  def find_spec_and_start_local_child(child_id, state) do
+    case Distribution.find_spec(state.scope, child_id) do
+      {:ok, child_spec} ->
+        {_, _, state} = start_local_child(child_spec, state)
+        state
+
+      _ ->
+        state
+    end
+  end
+
   defp monitor_children(children) do
     Enum.reduce(children, {%{}, %{}, %{}}, fn
       {_, {:restarting, _}}, acc ->

lib/syn_supervisor/distribution.ex

@@ -35,7 +35,6 @@ defmodule SynSupervisor.Distribution do
       id: id,
       node: node,
       pid: child_pid,
-      spec: child_spec,
       supervisor_pid: supervisor
     }
 
@@ -75,6 +74,11 @@ defmodule SynSupervisor.Distribution do
     end
   end
 
+  @spec spec_for_child(scope_t(), Child.t()) :: {:ok, Child.spec_t()} | {:error, :not_found}
+  def spec_for_child(scope, %Child{} = c) do
+    find_spec(scope, c.id)
+  end
+
   @spec list_children(scope_t()) :: list(Child.t())
   def list_children(scope) do
     scope
@@ -161,8 +165,12 @@ defmodule SynSupervisor.Distribution do
     |> Enum.map(&:syn.join(spec_scope(scope), child_id, &1, child_spec))
   end
 
-  @spec untrack_spec(scope_t(), Child.spec_t()) :: list(:ok | {:error, term()})
+  @spec untrack_spec(scope_t(), Child.spec_t() | Child.id_t()) :: list(:ok | {:error, term()})
   def untrack_spec(scope, {child_id, _, _, _, _, _}) do
+    untrack_spec(scope, child_id)
+  end
+
+  def untrack_spec(scope, child_id) do
     scope
     |> supervisors()
     |> Enum.map(&:syn.leave(spec_scope(scope), child_id, &1))

lib/syn_supervisor/distribution/child.ex

@@ -10,10 +10,9 @@ defmodule SynSupervisor.Distribution.Child do
           id: id_t(),
           pid: pid(),
           node: Node.t(),
-          supervisor_pid: pid(),
-          spec: spec_t()
+          supervisor_pid: pid()
         }
 
-  @enforce_keys [:id, :pid, :node, :supervisor_pid, :spec]
-  defstruct [:id, :pid, :node, :supervisor_pid, :spec]
+  @enforce_keys [:id, :pid, :node, :supervisor_pid]
+  defstruct [:id, :pid, :node, :supervisor_pid]
 end