fix: disable compiler mode until nif_call fix" (#89)

* fix: disable compiler mode until nif_call fix

* fix: remove nif call runner from app tree

Author: polvalente

lib/emlx.ex

@@ -326,125 +326,10 @@ defmodule EMLX do
   @behaviour Nx.Defn.Compiler
 
   @impl Nx.Defn.Compiler
-  def __jit__(key, vars, fun, args_list, opts) do
-    __compile__(key, vars, fun, opts).(args_list)
-  end
+  defdelegate __jit__(key, vars, fun, args_list, opts), to: Nx.Defn.Evaluator
 
   @impl Nx.Defn.Compiler
-  def __compile__(key, vars, fun, opts) do
-    backend = Nx.default_backend()
-
-    target_backend =
-      case backend do
-        EMLX.Backend ->
-          backend
-
-        {EMLX.Backend, _} ->
-          backend
-
-        Nx.BinaryBackend ->
-          EMLX.Backend
-
-        {Nx.BinaryBackend, _} ->
-          EMLX.Backend
-
-        other ->
-          raise ArgumentError,
-                "EMLX can only be used with the EMLX.Backend or Nx.BinaryBackend, got: #{inspect(other)}"
-      end
-
-    expr = fun.(vars)
-
-    fn [args] ->
-      {devices, nif_args} =
-        Enum.map(args, fn arg ->
-          case arg.() do
-            %Nx.Tensor{data: %EMLX.Backend{ref: {device, ref}}} ->
-              {device, ref}
-
-            %Nx.Tensor{data: %Nx.BinaryBackend{}} = t ->
-              %Nx.Tensor{data: %EMLX.Backend{ref: {device, ref}}} =
-                Nx.backend_copy(t, target_backend)
-
-              {device, ref}
-
-            other ->
-              %Nx.Tensor{data: %EMLX.Backend{ref: {device, ref}}} = Nx.to_tensor(other)
-              {device, ref}
-          end
-        end)
-        |> Enum.unzip()
-
-      device =
-        Enum.reduce_while(devices, :cpu, fn
-          :gpu, _ ->
-            {:halt, :gpu}
-
-          _, acc ->
-            {:cont, acc}
-        end)
-
-      cache_key = {__MODULE__, :compiled_fun, key}
-
-      compiled_fun =
-        case :persistent_term.get(cache_key, :not_found) do
-          :not_found ->
-            eval_fun = Nx.Defn.Evaluator.__compile__(key, vars, fun, opts)
-
-            EMLX.NIF.set_compile(true)
-
-            evaluator_pid = Process.whereis(EMLX.Runner)
-
-            if not Process.alive?(evaluator_pid) do
-              raise "EMLX.Runner not alive"
-            end
-
-            callback = fn args ->
-              args = Enum.map(args, fn ref -> fn -> EMLX.Backend.to_nx({device, ref}) end end)
-
-              eval_fun.([args])
-              |> Nx.Defn.Composite.flatten_list()
-              |> Enum.map(fn %Nx.Tensor{data: %{ref: {_device, ref}}} -> ref end)
-            end
-
-            fun = NifCall.run(EMLX.Runner, callback, &nif_compile(nif_args, &1))
-
-            EMLX.NIF.set_compile(false)
-
-            :persistent_term.put(cache_key, fun)
-            fun
-
-          cached_fun ->
-            cached_fun
-        end
-
-      nif_result =
-        case device do
-          :cpu -> EMLX.NIF.call_compiled_cpu(compiled_fun, nif_args)
-          :gpu -> EMLX.NIF.call_compiled_gpu(compiled_fun, nif_args)
-        end
-
-      results =
-        nif_result
-        |> unwrap!()
-        |> Enum.map(fn ref ->
-          EMLX.Backend.to_nx({device, ref})
-        end)
-
-      {result, []} =
-        Nx.Defn.Composite.traverse(expr, results, fn _node, [h | t] ->
-          {h, t}
-        end)
-
-      [result]
-    end
-  end
-
-  defp nif_compile(nif_args, tag) do
-    nif_args
-    |> EMLX.NIF.compile(tag)
-    |> unwrap!()
-  end
+  defdelegate __compile__(key, vars, fun, opts), to: Nx.Defn.Evaluator
 
   @impl Nx.Defn.Compiler
   defdelegate __partitions_options__(opts), to: Nx.Defn.Evaluator

lib/emlx/application.ex

@@ -2,9 +2,7 @@ defmodule EMLX.Application do
   use Application
 
   def start(_type, _args) do
-    children = [
-      {NifCall.Runner, runner_opts: [nif_module: EMLX.NIF], name: EMLX.Runner}
-    ]
+    children = []
 
     Supervisor.start_link(children, strategy: :one_for_one, name: EMLX.Supervisor)
   end