Improve tournament performance

Author: vtm9

services/app/apps/codebattle/lib/codebattle/tournament/server.ex

@@ -11,6 +11,7 @@ defmodule Codebattle.Tournament.Server do
   require Logger
 
   @type tournament_id :: pos_integer()
+  @tournament_info_table :tournament_info_cache
   @waiting_room_timeout_ms to_timeout(second: 1)
   # API
   def start_link(tournament_id) do
@@ -26,7 +27,15 @@ defmodule Codebattle.Tournament.Server do
   end
 
   def get_tournament_info(id) do
-    GenServer.call(server_name(id), :get_tournament_info)
+    # Try to get from ETS cache first
+    case :ets.lookup(@tournament_info_table, id) do
+      [{^id, tournament_info}] ->
+        tournament_info
+
+      [] ->
+        # Fall back to GenServer call if not in cache
+        GenServer.call(server_name(id), :get_tournament_info, 20_000)
+    end
   catch
     :exit, {:noproc, _} ->
       nil
@@ -37,7 +46,7 @@ defmodule Codebattle.Tournament.Server do
   end
 
   def get_tournament(id) do
-    GenServer.call(server_name(id), :get_tournament)
+    GenServer.call(server_name(id), :get_tournament, 20_000)
   catch
     :exit, {:noproc, _} ->
       nil
@@ -60,7 +69,8 @@ defmodule Codebattle.Tournament.Server do
   def finish_round_after(tournament_id, round_position, timeout_in_seconds) do
     GenServer.call(
       server_name(tournament_id),
-      {:finish_round_after, round_position, timeout_in_seconds}
+      {:finish_round_after, round_position, timeout_in_seconds},
+      30_000
     )
   catch
     :exit, reason ->
@@ -82,7 +92,7 @@ defmodule Codebattle.Tournament.Server do
   end
 
   def handle_event(tournament_id, event_type, params) do
-    GenServer.call(server_name(tournament_id), {:fire_event, event_type, params})
+    GenServer.call(server_name(tournament_id), {:fire_event, event_type, params}, 20_000)
   catch
     :exit, reason ->
       Logger.error("Error to send tournament update: #{inspect(reason)}")
@@ -91,6 +101,11 @@ defmodule Codebattle.Tournament.Server do
 
   # SERVER
   def init(tournament_id) do
+    # Create tournament_info_cache table if it doesn't exist
+    if :ets.whereis(@tournament_info_table) == :undefined do
+      :ets.new(@tournament_info_table, [:named_table, :set, :public, read_concurrency: true])
+    end
+
     players_table = Tournament.Players.create_table(tournament_id)
     matches_table = Tournament.Matches.create_table(tournament_id)
     tasks_table = Tournament.Tasks.create_table(tournament_id)
@@ -138,6 +153,23 @@ defmodule Codebattle.Tournament.Server do
   end
 
   def handle_call({:update, new_tournament}, _from, state) do
+    # Update the tournament_info cache when tournament is updated
+    tournament_info =
+      Map.drop(new_tournament, [
+        :__struct__,
+        :__meta__,
+        :creator,
+        :event,
+        :matches,
+        :players,
+        :waiting_room_state,
+        :stats,
+        :played_pair_ids,
+        :round_tasks
+      ])
+
+    :ets.insert(@tournament_info_table, {new_tournament.id, tournament_info})
+
     broadcast_tournament_update(new_tournament)
     {:reply, :ok, %{state | tournament: new_tournament}}
   end
@@ -167,19 +199,24 @@ defmodule Codebattle.Tournament.Server do
   end
 
   def handle_call(:get_tournament_info, _from, state) do
-    {:reply,
-     Map.drop(state.tournament, [
-       :__struct__,
-       :__meta__,
-       :creator,
-       :event,
-       :matches,
-       :players,
-       :waiting_room_state,
-       :stats,
-       :played_pair_ids,
-       :round_tasks
-     ]), state}
+    tournament_info =
+      Map.drop(state.tournament, [
+        :__struct__,
+        :__meta__,
+        :creator,
+        :event,
+        :matches,
+        :players,
+        :waiting_room_state,
+        :stats,
+        :played_pair_ids,
+        :round_tasks
+      ])
+
+    # Update the cache
+    :ets.insert(@tournament_info_table, {state.tournament.id, tournament_info})
+
+    {:reply, tournament_info, state}
   end
 
   def handle_call({:fire_event, event_type, params}, _from, %{tournament: tournament} = state) do
@@ -192,6 +229,23 @@ defmodule Codebattle.Tournament.Server do
         apply(module, event_type, [tournament, params])
       end
 
+    # Update the tournament_info cache when firing events
+    tournament_info =
+      Map.drop(new_tournament, [
+        :__struct__,
+        :__meta__,
+        :creator,
+        :event,
+        :matches,
+        :players,
+        :waiting_room_state,
+        :stats,
+        :played_pair_ids,
+        :round_tasks
+      ])
+
+    :ets.insert(@tournament_info_table, {new_tournament.id, tournament_info})
+
     # TODO: rethink broadcasting during applying event, maybe put inside tournament module
     broadcast_tournament_event_by_type(event_type, params, new_tournament)
 

services/app/apps/codebattle/lib/codebattle/tournament/strategy/base.ex

@@ -577,19 +577,33 @@ defmodule Codebattle.Tournament.Base do
       end
 
       defp start_round(tournament, round_params \\ %{}) do
+        # Perform initial updates in a single operation
+        tournament =
+          update_struct(tournament, %{
+            break_state: "off",
+            last_round_started_at: NaiveDateTime.utc_now(:second),
+            match_timeout_seconds: Map.get(round_params, :timeout_seconds, tournament.match_timeout_seconds)
+          })
+
+        # Build and save round first - this is a critical operation
+        tournament = build_and_save_round!(tournament)
+
+        # Perform these operations in sequence as they depend on each other
+        tournament =
+          tournament
+          |> maybe_preload_tasks()
+          |> maybe_set_round_task_ids()
+          |> maybe_start_round_timer()
+          |> maybe_activate_players()
+
+        # Build matches - this is the most time-consuming part
+        tournament = build_round_matches(tournament, round_params)
+
+        # Save to database
+        tournament = db_save!(tournament)
+
+        # These operations can be done after the critical path
         tournament
-        |> update_struct(%{
-          break_state: "off",
-          last_round_started_at: NaiveDateTime.utc_now(:second),
-          match_timeout_seconds: Map.get(round_params, :timeout_seconds, tournament.match_timeout_seconds)
-        })
-        |> build_and_save_round!()
-        |> maybe_preload_tasks()
-        |> maybe_set_round_task_ids()
-        |> maybe_start_round_timer()
-        |> maybe_activate_players()
-        |> build_round_matches(round_params)
-        |> db_save!()
         |> maybe_start_waiting_room()
         |> broadcast_round_created()
       end
@@ -648,40 +662,51 @@ defmodule Codebattle.Tournament.Base do
       defp bulk_create_round_games_and_matches(batch, tournament, task, timeout_seconds) do
         reset_task_ids = tournament.task_provider == "task_pack_per_round"
 
-        batch
-        |> Enum.map(fn
-          # TODO: skip bots game
-          # {[p1 = %{is_bot: true}, p2 = %{is_bot: true}], match_id} ->
-          #   Tournament.Matches.put_match(tournament, %Tournament.Match{
-          #     id: match_id,
-          #     state: "canceled",
-          #     round_id: tournament.current_round_id,
-          #     round_position: tournament.current_round_position,
-          #     player_ids: Enum.sort([p1.id, p2.id])
-          #   })
-
-          {[p1, p2] = players, match_id} ->
-            %{
-              players: players,
-              ref: match_id,
-              round_id: tournament.current_round_id,
-              state: "playing",
-              task: task,
-              waiting_room_name: tournament.waiting_room_name,
-              timeout_seconds: timeout_seconds,
-              tournament_id: tournament.id,
-              type: game_type(),
-              use_chat: tournament.use_chat,
-              use_timer: tournament.use_timer
-            }
-            |> maybe_set_free_task(tournament, p1)
-            |> maybe_add_award(tournament)
-        end)
-        |> Game.Context.bulk_create_games()
-        |> Enum.zip(batch)
-        |> Enum.each(fn {game, {players, _match_id}} ->
-          build_and_run_match(tournament, players, game, reset_task_ids)
-        end)
+        # Prepare game creation parameters in a single pass
+        game_params =
+          Enum.map(batch, fn
+            {[p1, p2] = players, match_id} ->
+              base_params = %{
+                players: players,
+                ref: match_id,
+                round_id: tournament.current_round_id,
+                state: "playing",
+                task: task,
+                waiting_room_name: tournament.waiting_room_name,
+                timeout_seconds: timeout_seconds,
+                tournament_id: tournament.id,
+                type: game_type(),
+                use_chat: tournament.use_chat,
+                use_timer: tournament.use_timer
+              }
+
+              # Apply transformations
+              params =
+                base_params
+                |> maybe_set_free_task(tournament, p1)
+                |> maybe_add_award(tournament)
+
+              {params, players, match_id}
+          end)
+
+        # Extract just the game parameters for bulk creation
+        game_creation_params = Enum.map(game_params, fn {params, _players, _match_id} -> params end)
+
+        # Create games in bulk
+        created_games = Game.Context.bulk_create_games(game_creation_params)
+
+        # Process matches in parallel using Task.async_stream with controlled concurrency
+        created_games
+        |> Enum.zip(game_params)
+        |> Task.async_stream(
+          fn {game, {_params, players, _match_id}} ->
+            build_and_run_match(tournament, players, game, reset_task_ids)
+          end,
+          max_concurrency: System.schedulers_online(),
+          ordered: false,
+          timeout: 30_000
+        )
+        |> Stream.run()
       end
 
       defp create_rematch_game(tournament, players, ref) do
@@ -1026,43 +1051,77 @@ defmodule Codebattle.Tournament.Base do
         matches_to_finish = get_matches(tournament, "playing")
         finished_at = DateTime.utc_now(:second)
 
-        Enum.each(
-          matches_to_finish,
-          fn match ->
-            duration_sec = NaiveDateTime.diff(finished_at, match.started_at)
-
-            player_results = improve_player_results(tournament, match, duration_sec)
-            Game.Context.trigger_timeout(match.game_id)
+        # Early return if no matches to finish
+        if matches_to_finish == [] do
+          tournament
+        else
+          # Process matches in parallel with Task.async_stream
+          match_results =
+            matches_to_finish
+            |> Task.async_stream(
+              fn match ->
+                duration_sec = NaiveDateTime.diff(finished_at, match.started_at)
+
+                # Get player results and trigger timeout
+                player_results = improve_player_results(tournament, match, duration_sec)
+                Game.Context.trigger_timeout(match.game_id)
+
+                # Create new match with timeout state
+                new_match = %{
+                  match
+                  | state: "timeout",
+                    player_results: player_results,
+                    duration_sec: duration_sec,
+                    finished_at: finished_at
+                }
+
+                # Return match and player data for batch processing
+                {new_match, player_results}
+              end,
+              max_concurrency: System.schedulers_online() * 2,
+              timeout: 10_000
+            )
+            |> Enum.to_list()
 
-            new_match = %{
-              match
-              | state: "timeout",
-                player_results: player_results,
-                duration_sec: duration_sec,
-                finished_at: finished_at
-            }
+          # Batch update matches and collect player updates
+          player_updates =
+            Enum.reduce(match_results, %{}, fn {:ok, {new_match, player_results}}, acc ->
+              # Update match in tournament
+              Tournament.Matches.put_match(tournament, new_match)
 
-            Tournament.Matches.put_match(tournament, new_match)
+              # Broadcast match update
+              Codebattle.PubSub.broadcast("tournament:match:upserted", %{
+                tournament: tournament,
+                match: new_match
+              })
 
-            Codebattle.PubSub.broadcast("tournament:match:upserted", %{
-              tournament: tournament,
-              match: new_match
-            })
+              # Collect player updates
+              Enum.reduce(player_results, acc, fn {player_id, result}, player_acc ->
+                player_score = result.score
+                player_lang = result.lang
 
-            player_results
-            |> Map.keys()
-            |> Enum.each(fn player_id ->
-              player = Tournament.Players.get_player(tournament, player_id)
-
-              player &&
-                Tournament.Players.put_player(tournament, %{
-                  player
-                  | score: player.score + player_results[player_id].score,
-                    lang: player_results[player_id].lang
-                })
+                # credo:disable-for-next-line Credo.Check.Refactor.Nesting
+                Map.update(player_acc, player_id, %{score: player_score, lang: player_lang}, fn existing ->
+                  %{score: existing.score + player_score, lang: player_lang}
+                end)
+              end)
             end)
-          end
-        )
+
+          # Batch update player scores
+          Enum.each(player_updates, fn {player_id, updates} ->
+            player = Tournament.Players.get_player(tournament, player_id)
+
+            if player do
+              Tournament.Players.put_player(tournament, %{
+                player
+                | score: player.score + updates.score,
+                  lang: updates.lang
+              })
+            end
+          end)
+
+          tournament
+        end
       end
 
       defp improve_player_results(tournament, match, duration_sec) do