Always pass parallel checker cache around

josevalim · josevalim · commit a1d491d85ea0 · 2024-11-18T18:15:55.000+01:00
diff --git a/lib/elixir/lib/kernel/parallel_compiler.ex b/lib/elixir/lib/kernel/parallel_compiler.ex
@@ -31,11 +31,11 @@ defmodule Kernel.ParallelCompiler do
         dest = :erlang.get(:elixir_compiler_dest)
 
         {:error_handler, error_handler} = :erlang.process_info(self(), :error_handler)
-        {_parent, checker} = Module.ParallelChecker.get()
+        {_parent, cache} = Module.ParallelChecker.get()
 
         task =
           Task.async(fn ->
-            Module.ParallelChecker.put(compiler_pid, checker)
+            Module.ParallelChecker.put(compiler_pid, cache)
             :erlang.put(:elixir_compiler_info, {compiler_pid, file_pid})
             :erlang.put(:elixir_compiler_file, file)
             dest != :undefined and :erlang.put(:elixir_compiler_dest, dest)
@@ -253,11 +253,11 @@ defmodule Kernel.ParallelCompiler do
         max(:erlang.system_info(:schedulers_online), 2)
       end)
 
-    {:ok, checker} = Module.ParallelChecker.start_link(schedulers)
+    {:ok, cache} = Module.ParallelChecker.start_link(schedulers)
 
     {status, modules_or_errors, info} =
       try do
-        outcome = spawn_workers(schedulers, checker, files, output, options)
+        outcome = spawn_workers(schedulers, cache, files, output, options)
         {outcome, Keyword.get(options, :warnings_as_errors, false)}
       else
         {{:ok, _, %{runtime_warnings: r_warnings, compile_warnings: c_warnings} = info}, true}
@@ -281,7 +281,7 @@ defmodule Kernel.ParallelCompiler do
         {{:error, errors, info}, _} ->
           {:error, errors, info}
       after
-        Module.ParallelChecker.stop(checker)
+        Module.ParallelChecker.stop(cache)
       end
 
     # TODO: Require this to be set from Elixir v1.19
@@ -428,13 +428,13 @@ defmodule Kernel.ParallelCompiler do
   end
 
   defp spawn_workers([file | queue], spawned, waiting, files, result, warnings, errors, state) do
-    %{output: output, dest: dest, checker: checker} = state
+    %{output: output, dest: dest, checker: cache} = state
     parent = self()
     file = Path.expand(file)
 
     {pid, ref} =
       :erlang.spawn_monitor(fn ->
-        Module.ParallelChecker.put(parent, checker)
+        Module.ParallelChecker.put(parent, cache)
         :erlang.put(:elixir_compiler_info, {parent, self()})
         :erlang.put(:elixir_compiler_file, file)
 
diff --git a/lib/elixir/lib/module/parallel_checker.ex b/lib/elixir/lib/module/parallel_checker.ex
@@ -11,13 +11,13 @@ defmodule Module.ParallelChecker do
   Initializes the parallel checker process.
   """
   def start_link(schedulers \\ nil) do
-    :gen_server.start_link(__MODULE__, schedulers, [])
+    :proc_lib.start_link(__MODULE__, :init, [schedulers])
   end
 
   @doc """
   Stops the parallel checker process.
   """
-  def stop(checker) do
+  def stop({checker, _table}) do
     send(checker, {__MODULE__, :stop})
     :ok
   end
@@ -28,39 +28,38 @@ defmodule Module.ParallelChecker do
   def get do
     case :erlang.get(:elixir_checker_info) do
       {parent, nil} ->
-        {:ok, checker} = start_link()
-        put(parent, checker)
-        {parent, checker}
+        {:ok, checker_table} = start_link()
+        put(parent, checker_table)
+        {parent, checker_table}
 
-      {parent, checker} ->
-        {parent, checker}
+      {parent, checker_table} ->
+        {parent, checker_table}
     end
   end
 
   @doc """
   Stores the parallel checker information.
   """
-  def put(pid, checker) when is_pid(pid) and is_pid(checker) do
-    :erlang.put(:elixir_checker_info, {pid, checker})
+  def put(pid, {checker, table}) when is_pid(pid) do
+    :erlang.put(:elixir_checker_info, {pid, {checker, table}})
   end
 
   @doc """
   Spawns a process that runs the parallel checker.
   """
-  def spawn({pid, checker}, module, module_map, log?) do
-    ets = :gen_server.call(checker, :ets, :infinity)
-    inner_spawn(pid, checker, module, cache_from_module_map(ets, module_map), log?)
+  def spawn({pid, {checker, table}}, module, module_map, log?) do
+    inner_spawn(pid, checker, table, module, cache_from_module_map(table, module_map), log?)
   end
 
-  defp inner_spawn(pid, checker, module, info, log?) do
+  defp inner_spawn(pid, checker, table, module, info, log?) do
     ref = make_ref()
 
     spawned =
       spawn(fn ->
         mon_ref = Process.monitor(pid)
 
         receive do
-          {^ref, :cache, ets} ->
+          {^ref, :cache} ->
             Process.link(pid)
 
             module_tuple =
@@ -73,7 +72,7 @@ defmodule Module.ParallelChecker do
                        {:ok, {_, [debug_info: chunk]}} <- :beam_lib.chunks(binary, [:debug_info]),
                        {:debug_info_v1, backend, data} = chunk,
                        {:ok, module_map} <- backend.debug_info(:elixir_v1, module, data, []) do
-                    cache_from_module_map(ets, module_map)
+                    cache_from_module_map(table, module_map)
                   else
                     _ -> nil
                   end
@@ -88,7 +87,7 @@ defmodule Module.ParallelChecker do
 
                 warnings =
                   if module_tuple do
-                    check_module(module_tuple, {checker, ets}, log?)
+                    check_module(module_tuple, {checker, table}, log?)
                   else
                     []
                   end
@@ -122,20 +121,20 @@ defmodule Module.ParallelChecker do
 
           case :erlang.get(:elixir_checker_info) do
             {_, nil} -> :ok
-            {_, checker} -> verify(checker, [])
+            {_, cache} -> verify(cache, [])
           end
 
           result
         after
-          {_, checker} = :erlang.get(:elixir_checker_info)
+          {_, cache} = :erlang.get(:elixir_checker_info)
 
           if previous != :undefined do
             :erlang.put(:elixir_checker_info, previous)
           else
             :erlang.erase(:elixir_checker_info)
           end
 
-          checker && stop(checker)
+          cache && stop(cache)
         end
 
       _ ->
@@ -150,13 +149,13 @@ defmodule Module.ParallelChecker do
   the modules and adds the ExCk chunk to the binaries. Returns the updated
   list of warnings from the verification.
   """
-  @spec verify(pid(), [{module(), Path.t()}]) :: [warning()]
-  def verify(checker, runtime_files) do
+  @spec verify(cache(), [{module(), Path.t()}]) :: [warning()]
+  def verify({checker, table}, runtime_files) do
     value = :erlang.get(:elixir_code_diagnostics)
     log? = not match?({_, false}, value)
 
     for {module, file} <- runtime_files do
-      inner_spawn(self(), checker, module, file, log?)
+      inner_spawn(self(), checker, table, module, file, log?)
     end
 
     count = :gen_server.call(checker, :start, :infinity)
@@ -190,8 +189,8 @@ defmodule Module.ParallelChecker do
   Test cache.
   """
   def test_cache do
-    {:ok, checker} = start_link()
-    {checker, :gen_server.call(checker, :ets, :infinity)}
+    {:ok, checker_table} = start_link()
+    checker_table
   end
 
   @doc """
@@ -202,17 +201,17 @@ defmodule Module.ParallelChecker do
   @spec fetch_export(cache(), module(), atom(), arity()) ::
           {:ok, mode(), binary() | nil, {:infer, [term()]} | :none}
           | {:error, :function | :module}
-  def fetch_export({server, ets}, module, fun, arity) do
-    case :ets.lookup(ets, module) do
+  def fetch_export({checker, table}, module, fun, arity) do
+    case :ets.lookup(table, module) do
       [] ->
-        cache_module({server, ets}, module)
-        fetch_export({server, ets}, module, fun, arity)
+        cache_module({checker, table}, module)
+        fetch_export({checker, table}, module, fun, arity)
 
       [{_key, false}] ->
         {:error, :module}
 
       [{_key, mode}] ->
-        case :ets.lookup(ets, {module, {fun, arity}}) do
+        case :ets.lookup(table, {module, {fun, arity}}) do
           [{_key, reason, signature}] -> {:ok, mode, reason, signature}
           [] -> {:error, :function}
         end
@@ -371,37 +370,37 @@ defmodule Module.ParallelChecker do
 
   ## Cache
 
-  defp cache_module({server, ets}, module) do
-    if lock(server, module) do
+  defp cache_module({checker, table}, module) do
+    if lock(checker, module) do
       object_code = :code.get_object_code(module)
 
       # The chunk has more information, so that's our preference
       with {^module, binary, _filename} <- object_code,
            {:ok, {^module, [{~c"ExCk", chunk}]}} <- :beam_lib.chunks(binary, [~c"ExCk"]),
            {:elixir_checker_v1, contents} <- :erlang.binary_to_term(chunk) do
-        cache_chunk(ets, module, contents.exports)
+        cache_chunk(table, module, contents.exports)
       else
         _ ->
           # Otherwise, if the module is loaded, use its info
           case :erlang.module_loaded(module) do
             true ->
               {mode, exports} = info_exports(module)
               deprecated = info_deprecated(module)
-              cache_info(ets, module, exports, deprecated, %{}, mode)
+              cache_info(table, module, exports, deprecated, %{}, mode)
 
             false ->
               # Or load exports from chunk
               with {^module, binary, _filename} <- object_code,
                    {:ok, {^module, [exports: exports]}} <- :beam_lib.chunks(binary, [:exports]) do
-                cache_info(ets, module, exports, %{}, %{}, :erlang)
+                cache_info(table, module, exports, %{}, %{}, :erlang)
               else
                 _ ->
-                  :ets.insert(ets, {module, false})
+                  :ets.insert(table, {module, false})
               end
           end
       end
 
-      unlock(server, module)
+      unlock(checker, module)
     end
   end
 
@@ -417,36 +416,36 @@ defmodule Module.ParallelChecker do
     _ -> %{}
   end
 
-  defp cache_from_module_map(ets, map) do
+  defp cache_from_module_map(table, map) do
     exports =
       [{:__info__, 1}] ++
         behaviour_exports(map) ++
         for({function, :def, _meta, _clauses} <- map.definitions, do: function)
 
-    cache_info(ets, map.module, exports, Map.new(map.deprecated), map.signatures, :elixir)
+    cache_info(table, map.module, exports, Map.new(map.deprecated), map.signatures, :elixir)
     module_map_to_module_tuple(map)
   end
 
-  defp cache_info(ets, module, exports, deprecated, sigs, mode) do
+  defp cache_info(table, module, exports, deprecated, sigs, mode) do
     Enum.each(exports, fn fa ->
       reason = Map.get(deprecated, fa)
-      :ets.insert(ets, {{module, fa}, reason, Map.get(sigs, fa, :none)})
+      :ets.insert(table, {{module, fa}, reason, Map.get(sigs, fa, :none)})
     end)
 
-    :ets.insert(ets, {module, mode})
+    :ets.insert(table, {module, mode})
   end
 
-  defp cache_chunk(ets, module, exports) do
+  defp cache_chunk(table, module, exports) do
     Enum.each(exports, fn {{fun, arity}, info} ->
       # TODO: Match on signature directly in Elixir v1.22+
       :ets.insert(
-        ets,
+        table,
         {{module, {fun, arity}}, Map.get(info, :deprecated), Map.get(info, :sig, :none)}
       )
     end)
 
-    :ets.insert(ets, {{module, {:__info__, 1}}, nil, :none})
-    :ets.insert(ets, {module, :elixir})
+    :ets.insert(table, {{module, {:__info__, 1}}, nil, :none})
+    :ets.insert(table, {module, :elixir})
   end
 
   defp behaviour_exports(%{defines_behaviour: true}), do: [{:behaviour_info, 1}]
@@ -475,22 +474,22 @@ defmodule Module.ParallelChecker do
   ## Server callbacks
 
   def init(schedulers) do
-    ets = :ets.new(__MODULE__, [:set, :public, {:read_concurrency, true}])
+    table = :ets.new(__MODULE__, [:set, :public, {:read_concurrency, true}])
+    :proc_lib.init_ack({:ok, {self(), table}})
 
     state = %{
-      ets: ets,
       waiting: %{},
       modules: [],
       spawned: 0,
       schedulers: schedulers || max(:erlang.system_info(:schedulers_online), 2)
     }
 
-    {:ok, state}
+    :gen_server.enter_loop(__MODULE__, [], state)
   end
 
-  def handle_call(:start, _from, %{ets: ets, modules: modules} = state) do
+  def handle_call(:start, _from, %{modules: modules} = state) do
     for {pid, ref} <- modules do
-      send(pid, {ref, :cache, ets})
+      send(pid, {ref, :cache})
     end
 
     for {_pid, ref} <- modules do
@@ -502,10 +501,6 @@ defmodule Module.ParallelChecker do
     {:reply, length(modules), run_checkers(state)}
   end
 
-  def handle_call(:ets, _from, state) do
-    {:reply, state.ets, state}
-  end
-
   def handle_call({:lock, module}, from, %{waiting: waiting} = state) do
     case waiting do
       %{^module => froms} ->
diff --git a/lib/elixir/test/elixir/kernel/raise_test.exs b/lib/elixir/test/elixir/kernel/raise_test.exs
@@ -434,15 +434,15 @@ defmodule Kernel.RaiseTest do
 
       :code.purge(BadFunction.Missing)
 
-      result =
-        try do
-          fun.()
-        rescue
-          x in [BadFunctionError] -> Exception.message(x)
-        end
-
-      assert result =~
-               ~r/function #Function<[0-9]\.[0-9]*\/0[^>]*> is invalid, likely because it points to an old version of the code/
+      try do
+        fun.()
+      rescue
+        x in [BadFunctionError] ->
+          assert Exception.message(x) =~
+                   ~r/function #Function<[0-9]\.[0-9]*\/0[^>]*> is invalid, likely because it points to an old version of the code/
+      else
+        _ -> flunk("this should not be invoked")
+      end
     end
 
     test "badmatch error" do
