Fix viewer for new multiprocessing matrix building

Author: yolo h8cker 93

.cursor/rules/viewer.mdc

@@ -405,21 +405,21 @@ If a file `matrix.json` exists, load it. It looks like this:
   "matrices": {
     "sonnet-4_vs_sonnet-4": {
       "0": {
-        "0": {
+        "1": {
           "round_num": "e2513f264ac04a019c25982d2b03b3bb",
           "winner": "sonnet-4_2",
           "scores": {
-            "sonnet-4_2": 1,
-            "sonnet-4_1": 0.0
+            "sonnet-4_r0": 1,
+            "sonnet-4_r1": 0.0
           },
           "player_stats": {
-            "sonnet-4_2": {
+            "sonnet-4_r0": {
               "name": "sonnet-4_2",
               "invalid_reason": "",
               "score": 1,
               "valid_submit": true
             },
-            "sonnet-4_1": {
+            "sonnet-4_r1": {
               "name": "sonnet-4_1",
               "invalid_reason": "",
               "score": 0.0,

codeclash/analysis/matrix.py

@@ -95,12 +95,6 @@ def _load_existing_progress(self):
         if "matrices" in existing_data:
             self._metadata["matrices"] = existing_data["matrices"]
 
-    def _save_progress(self):
-        """Save current progress to matrix.json in a thread-safe manner."""
-        with self._save_lock:
-            self.output_file.write_text(json.dumps(self._metadata, indent=2))
-            self.logger.debug("Progress saved to matrix.json")
-
     def _initialize_game_pool(self):
         """Initialize a pool of game objects for parallel execution."""
         self.game_pool = []
@@ -214,9 +208,16 @@ def _evaluate_matrix_cell_parallel(
 
         round_id = str(uuid.uuid4().hex)
         stats = game_worker.run_round([agent1, agent2], round_id)
-        self.logger.debug(f"Result: {stats.to_dict()}")
+        result = stats.to_dict()
+        self.logger.debug(f"Result: {result}")
 
-        return (i, j, stats.to_dict())
+        # Save the result immediately after computation
+        with self._save_lock:
+            self.matrices[matrix_id][str(i)][str(j)] = result
+            self.output_file.write_text(json.dumps(self._metadata, indent=2))
+            self.logger.debug(f"Saved result for {player1_name} round {i} vs {player2_name} round {j}")
+
+        return (i, j, result)
 
     def _evaluate_matrix(self, player1_name: str, player2_name: str):
         """Evaluate a matrix between two players using parallel execution."""
@@ -234,7 +235,7 @@ def _evaluate_matrix(self, player1_name: str, player2_name: str):
         game_worker_index = 0
 
         for i in range(self.rounds + 1):
-            j_range = range(i + 1) if symmetric else range(self.rounds + 1)
+            j_range = range(i) if symmetric else range(self.rounds + 1)
             for j in j_range:
                 # Skip if already completed
                 try:
@@ -258,19 +259,11 @@ def _evaluate_matrix(self, player1_name: str, player2_name: str):
         # Execute tasks in parallel
         with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
             # Submit all tasks
-            future_to_task = {executor.submit(self._evaluate_matrix_cell_parallel, *task): task for task in tasks}
-
-            # Process completed tasks as they finish
-            for future in as_completed(future_to_task):
-                i, j, result = future.result()
-                if result is not None:
-                    with self._save_lock:
-                        self.matrices[matrix_id][str(i)][str(j)] = result
-                    self._save_progress()
-
-                # Log progress
-                completed = len([f for f in future_to_task if f.done()])
-                self.logger.info(f"Progress: {completed}/{len(tasks)} matrix cells completed for {matrix_id}")
+            futures = [executor.submit(self._evaluate_matrix_cell_parallel, *task) for task in tasks]
+
+            # Wait for all tasks to complete
+            for future in as_completed(futures):
+                future.result()  # This will raise any exceptions that occurred
 
         self.logger.info(f"Completed matrix evaluation for {matrix_id}")
 

codeclash/viewer/app.py

@@ -628,11 +628,10 @@ def load_matrix_analysis(self) -> dict[str, Any] | None:
             for matrix_name, matrix in matrices.items():
                 processed_matrix = {"name": matrix_name, "data": {}, "max_rounds": 0}
 
-                # Find player 1 name (the one with _1 suffix in self-play matrices)
-                player1_name = None
+                # Extract base player name from matrix name
+                base_player_name = None
                 if "_vs_" in matrix_name:
-                    base_name = matrix_name.split("_vs_")[0]
-                    player1_name = f"{base_name}_1"
+                    base_player_name = matrix_name.split("_vs_")[0]
 
                 # Determine matrix dimensions
                 max_i = max_j = 0
@@ -655,19 +654,21 @@ def load_matrix_analysis(self) -> dict[str, Any] | None:
                         cell_data = matrix[i_str][j_str]
                         scores = cell_data.get("scores", {})
 
-                        # Calculate win percentage from player 1 perspective
-                        if player1_name and player1_name in scores:
-                            player1_score = scores.get(player1_name, 0)
+                        # Calculate win percentage from row player perspective (player using round i code)
+                        row_player_name = f"{base_player_name}_r{i}" if base_player_name else None
+
+                        if row_player_name and row_player_name in scores:
+                            row_player_score = scores.get(row_player_name, 0)
                             total_games = sum(scores.values())
 
                             if total_games > 0:
                                 # Handle ties if present
                                 ties = scores.get("Tie", 0)
-                                win_percentage = ((player1_score + 0.5 * ties) / total_games) * 100
+                                win_percentage = ((row_player_score + 0.5 * ties) / total_games) * 100
                             else:
                                 win_percentage = 0
                         else:
-                            # If we can't identify player 1, show raw scores
+                            # If we can't identify row player, show 0
                             win_percentage = 0
 
                         processed_matrix["data"][i][j] = {

codeclash/viewer/templates/includes/analysis.html

@@ -53,8 +53,8 @@ <h2><i class="bi bi-graph-up"></i> Analysis</h2>
                 <div class="matrix-table-container" id="matrix-{{ matrix_name }}" style="display: none;">
                     <h4>{{ matrix_name }}</h4>
                     <p class="matrix-description">
-                        Win percentages from player 1 perspective ({{ matrix_name.split('_vs_')[0] }}_1).
-                        Each cell shows the win rate when player 1 uses round i code vs round j code.
+                        Win percentages from row player perspective ({{ matrix_name.split('_vs_')[0] }}_r{i}).
+                        Each cell shows the win rate when the row player uses round i code vs round j code.
                     </p>
 
                     <div class="matrix-table-wrapper">