BattleSnake ladder repairs

Author: john-b-yang

codeclash/agents/player.py

@@ -60,8 +60,7 @@ def __init__(
 
         # Handle branch initialization
         if branch_init := config.get("branch_init"):
-            # Fetch from remote first (handles branches pushed in previous tournaments)
-            # Then checkout - git will create tracking branch if needed
+            # Fetch, then check out the initial branch (creating a tracking branch if needed).
             assert_zero_exit_code(
                 self.environment.execute(f"git fetch origin && git checkout {branch_init}"),
                 logger=self.logger,
@@ -70,20 +69,23 @@ def __init__(
 
         if self._branch_name != branch_init:
             self.logger.info(f"Switching to branch {self._branch_name} for pushing changes")
-            # First fetch to see if the branch exists on remote
-            assert_zero_exit_code(
-                self.environment.execute("git fetch origin"),
-                logger=self.logger,
-            )
-            # Try to checkout the branch - git will track remote if it exists there
-            checkout_result = self.environment.execute(f"git checkout {self._branch_name}")
-            if checkout_result.get("returncode", 0) != 0:
-                # Branch doesn't exist locally or remotely, create it
-                self.logger.info(f"Branch {self._branch_name} doesn't exist, creating it")
+            if branch_init:
+                # Start the push branch at branch_init. get_environment() pre-created a
+                # same-named branch at the default branch; a plain checkout would revert the
+                # working tree to it, so use -B to re-point it at the current HEAD.
                 assert_zero_exit_code(
-                    self.environment.execute(f"git checkout -b {self._branch_name}"),
+                    self.environment.execute(f"git checkout -B {self._branch_name}"),
                     logger=self.logger,
                 )
+            else:
+                # Resume the branch if a previous round pushed it to the remote, else create it.
+                assert_zero_exit_code(self.environment.execute("git fetch origin"), logger=self.logger)
+                if self.environment.execute(f"git checkout {self._branch_name}").get("returncode", 0) != 0:
+                    self.logger.info(f"Branch {self._branch_name} doesn't exist, creating it")
+                    assert_zero_exit_code(
+                        self.environment.execute(f"git checkout -b {self._branch_name}"),
+                        logger=self.logger,
+                    )
 
     # --- Main methods ---
 

codeclash/arenas/battlesnake/battlesnake.py

@@ -127,8 +127,13 @@ def execute_round(self, agents: list[Player]):
         try:
             self.logger.info(f"Running game with players: {list(player2port.keys())}")
 
-            # Use ThreadPoolExecutor for parallel execution
-            with ThreadPoolExecutor(20) as executor:
+            # Use ThreadPoolExecutor for parallel execution. Concurrency is configurable
+            # (game.sim_concurrency): the single-threaded bot servers serialize move
+            # requests, so total concurrency across all parallel pairs must stay bounded or
+            # responses exceed the move timeout and games degenerate. When running many pairs
+            # concurrently (ladder --workers), lower this so workers*sim_concurrency stays ~20.
+            max_sim_workers = self.game_config.get("sim_concurrency", 20)
+            with ThreadPoolExecutor(max_sim_workers) as executor:
                 # Submit all simulations to the thread pool
                 futures = [
                     executor.submit(self._run_single_simulation, player2port, idx)

codeclash/cli/ladder.py

@@ -1,7 +1,9 @@
 """`codeclash ladder` subcommands: build a ladder (make) and climb it (run)."""
 
+import copy
 import getpass
 import time
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from pathlib import Path
 
 import typer
@@ -10,8 +12,11 @@
 from codeclash import CONFIG_DIR
 from codeclash.constants import LOCAL_LOG_DIR
 from codeclash.tournaments.pvp import PvpTournament
+from codeclash.utils.log import get_logger
 from codeclash.utils.yaml_utils import resolve_includes
 
+logger = get_logger("ladder")
+
 ladder_app = typer.Typer(
     no_args_is_help=True, add_completion=False, context_settings={"help_option_names": ["-h", "--help"]}
 )
@@ -20,6 +25,9 @@
 @ladder_app.command("make")
 def make(
     config_path: Path = typer.Argument(..., help="Path to the ladder (round-robin) config file."),
+    workers: int = typer.Option(
+        1, "--workers", "-w", help="Pairwise tournaments to run concurrently (each pair is independent)."
+    ),
 ):
     """Build a ladder: run PvP tournaments across all pairs of players (for ranking)."""
     yaml_content = config_path.read_text()
@@ -28,24 +36,40 @@ def make(
 
     players = config["players"]
     num_players = len(players)
+
+    # Build one fully independent (deep-copied) config per pair up front so concurrent runs
+    # never share or mutate the same player/config dicts.
+    jobs: list[tuple[dict, Path]] = []
     for i in range(num_players):
         for j in range(i + 1, num_players):
-            player1 = players[i]
+            player1 = copy.deepcopy(players[i])
             player1["name"] = player1["branch_init"]
-            player2 = players[j]
+            player2 = copy.deepcopy(players[j])
             player2["name"] = player2["branch_init"]
-            pvp_config = {
-                **config,
-                "players": [player1, player2],
-            }
-
+            pvp_config = {**copy.deepcopy(config), "players": [player1, player2]}
             vs = f"PvpTournament.{player1['name']}_vs_{player2['name']}".replace("/", "_")
             output_dir = LOCAL_LOG_DIR / "ladder" / config["game"]["name"] / vs
-            try:
-                tournament = PvpTournament(pvp_config, output_dir=output_dir)
-            except FileExistsError:
-                continue
+            jobs.append((pvp_config, output_dir))
+
+    def run_pair(pvp_config: dict, output_dir: Path) -> None:
+        try:
+            tournament = PvpTournament(pvp_config, output_dir=output_dir)
+        except FileExistsError:
+            return  # already completed by a previous invocation
+        # A single failing pair must not abort the rest of a long round-robin.
+        try:
             tournament.run()
+        except Exception:
+            logger.exception(f"Pair failed, skipping: {output_dir.name}")
+
+    if workers <= 1:
+        for pvp_config, output_dir in jobs:
+            run_pair(pvp_config, output_dir)
+    else:
+        with ThreadPoolExecutor(max_workers=workers) as executor:
+            futures = [executor.submit(run_pair, c, d) for c, d in jobs]
+            for f in as_completed(futures):
+                f.result()
 
 
 @ladder_app.command("run")