997dd201c48cfc5a93ab9d8799c4f839ab1728ae

Committed 29 May 2025 07:59PM UTC coverage: 58.374% (-0.05%) from 58.426%

Build # 997dd201c48cfc5a93ab9d8799c4f839ab1728ae

Build Type

push

github

Committed by NSHkr

Commit Message

refactor performance_optimizer

Run Details

0 of 159 new or added lines in 6 files covered. (0.0%)

14 existing lines in 1 file now uncovered.

6082 of 10419 relevant lines covered (58.37%)

3184.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/lib/elixir_scope/ast_repository/performance_optimizer/batch_processor.ex

# ==============================================================================
# Batch Processing Component
# ==============================================================================

defmodule ElixirScope.ASTRepository.PerformanceOptimizer.BatchProcessor do
  @moduledoc """
  Handles batch operations for improved throughput and efficiency.
  """

  use GenServer
  require Logger

  alias ElixirScope.ASTRepository.EnhancedRepository

  @batch_size 50

  def start_link(opts \\ []) do
    GenServer.start_link(__MODULE__, opts, name: __MODULE__)
  end

  def init(_opts) do
    {:ok, %{queue: [], processing: false}}
  end

  @doc """
  Processes multiple modules in optimized batches.
  """
  @spec process_modules([{atom(), term()}], keyword()) :: {:ok, [term()]} | {:error, term()}
  def process_modules(modules, opts) do
    GenServer.call(__MODULE__, {:process_modules, modules, opts}, 60_000)
  end

  @doc """
  Queues a module for batch processing.
  """
  @spec queue_module(atom(), term(), keyword()) :: :ok
  def queue_module(module_name, ast, opts) do
    GenServer.cast(__MODULE__, {:queue_module, module_name, ast, opts})
  end

  def handle_call({:process_modules, modules, _opts}, _from, state) do
    try do
      results = process_modules_in_batches(modules)
      {:reply, {:ok, results}, state}
    rescue
      error ->
        Logger.error("Batch processing failed: #{inspect(error)}")
        {:reply, {:error, {:batch_failed, error}}, state}
    end
  end

  def handle_cast({:queue_module, module_name, ast, opts}, state) do
    new_queue = [{module_name, ast, opts} | state.queue]
    new_state = %{state | queue: new_queue}

    # Process queue if it reaches batch size
    if length(new_queue) >= @batch_size do
      spawn(fn -> process_queued_modules(new_queue) end)
      {:noreply, %{new_state | queue: [], processing: true}}
    else
      {:noreply, new_state}
    end
  end

  # Private implementation
  defp process_modules_in_batches(modules) do
    modules
    |> Enum.chunk_every(@batch_size)
    |> Enum.flat_map(fn batch ->
      tasks = Enum.map(batch, fn {module_name, ast} ->
        Task.async(fn ->
          case store_module_optimized(module_name, ast) do
            {:ok, data} -> data
            {:error, _} -> nil
          end
        end)
      end)

      Task.await_many(tasks, 30_000)
      |> Enum.filter(& &1)
    end)
  end

  defp process_queued_modules(queue) do
    queue
    |> Enum.map(fn {module_name, ast, opts} ->
      case EnhancedRepository.store_enhanced_module(module_name, ast, opts) do
        {:ok, data} -> data
        {:error, _} -> nil
      end
    end)
    |> Enum.filter(& &1)
  end

  defp store_module_optimized(module_name, ast) do
    opts = [analysis_level: [:basic_metrics, :dependencies], optimized: true]
    EnhancedRepository.store_enhanced_module(module_name, ast, opts)
  end
end

1	# ==============================================================================
2	# Batch Processing Component
3	# ==============================================================================
4
5	defmodule ElixirScope.ASTRepository.PerformanceOptimizer.BatchProcessor do
6	@moduledoc """
7	Handles batch operations for improved throughput and efficiency.
8	"""
9
10	use GenServer
11	require Logger
12
13	alias ElixirScope.ASTRepository.EnhancedRepository
14
15	@batch_size 50
16
17	def start_link(opts \\ []) do
NEW 18	GenServer.start_link(__MODULE__, opts, name: __MODULE__)	×
19	end
20
NEW 21	def init(_opts) do	×
22	{:ok, %{queue: [], processing: false}}
23	end
24
25	@doc """
26	Processes multiple modules in optimized batches.
27	"""
28	@spec process_modules([{atom(), term()}], keyword()) :: {:ok, [term()]} \| {:error, term()}
29	def process_modules(modules, opts) do
NEW 30	GenServer.call(__MODULE__, {:process_modules, modules, opts}, 60_000)	×
31	end
32
33	@doc """
34	Queues a module for batch processing.
35	"""
36	@spec queue_module(atom(), term(), keyword()) :: :ok
37	def queue_module(module_name, ast, opts) do
NEW 38	GenServer.cast(__MODULE__, {:queue_module, module_name, ast, opts})	×
39	end
40
41	def handle_call({:process_modules, modules, _opts}, _from, state) do
NEW 42	try do	×
NEW 43	results = process_modules_in_batches(modules)	×
NEW 44	{:reply, {:ok, results}, state}	×
45	rescue
NEW 46	error ->	×
NEW 47	Logger.error("Batch processing failed: #{inspect(error)}")	×
NEW 48	{:reply, {:error, {:batch_failed, error}}, state}	×
49	end
50	end
51
52	def handle_cast({:queue_module, module_name, ast, opts}, state) do
NEW 53	new_queue = [{module_name, ast, opts} \| state.queue]	×
NEW 54	new_state = %{state \| queue: new_queue}	×
55
56	# Process queue if it reaches batch size
NEW 57	if length(new_queue) >= @batch_size do	×
NEW 58	spawn(fn -> process_queued_modules(new_queue) end)	×
59	{:noreply, %{new_state \| queue: [], processing: true}}
60	else
61	{:noreply, new_state}
62	end
63	end
64
65	# Private implementation
66	defp process_modules_in_batches(modules) do
67	modules
68	\|> Enum.chunk_every(@batch_size)
NEW 69	\|> Enum.flat_map(fn batch ->	×
NEW 70	tasks = Enum.map(batch, fn {module_name, ast} ->	×
NEW 71	Task.async(fn ->	×
NEW 72	case store_module_optimized(module_name, ast) do	×
NEW 73	{:ok, data} -> data	×
NEW 74	{:error, _} -> nil	×
75	end
76	end)
77	end)
78
79	Task.await_many(tasks, 30_000)
NEW 80	\|> Enum.filter(& &1)	×
81	end)
82	end
83
84	defp process_queued_modules(queue) do
85	queue
86	\|> Enum.map(fn {module_name, ast, opts} ->
NEW 87	case EnhancedRepository.store_enhanced_module(module_name, ast, opts) do	×
NEW 88	{:ok, data} -> data	×
NEW 89	{:error, _} -> nil	×
90	end
91	end)
NEW 92	\|> Enum.filter(& &1)	×
93	end
94
95	defp store_module_optimized(module_name, ast) do
NEW 96	opts = [analysis_level: [:basic_metrics, :dependencies], optimized: true]	×
NEW 97	EnhancedRepository.store_enhanced_module(module_name, ast, opts)	×
98	end
99	end

nshkrdotcom / ElixirScope / 997dd201c48cfc5a93ab9d8799c4f839ab1728ae

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous