Method _evaluate_matrix

codeclash/analysis/matrix.py:247–296

Evaluate a matrix between two players using manual thread management.

(self, player1_name: str, player2_name: str)

        self.logger.debug(f"Worker {worker_id} stopped")

    def _evaluate_matrix(self, player1_name: str, player2_name: str):
        """Evaluate a matrix between two players using manual thread management."""
        symmetric = player1_name == player2_name
        matrix_id = f"{player1_name}_vs_{player2_name}"
        self.logger.info(f"Evaluating {matrix_id} matrix: {player1_name} vs {player2_name}")

        # Initialize matrix structure
        self.matrices.setdefault(matrix_id, {})
        for i in range(self.rounds + 1):
            self.matrices[matrix_id].setdefault(str(i), {})

        # Create task queue and populate it directly
        task_queue = Queue()
        task_count = 0

        for i in 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:
                    if self.matrices[matrix_id][str(i)][str(j)]:
                        continue
                except KeyError:
                    pass
                task_queue.put(
                    {"player1_name": player1_name, "player2_name": player2_name, "i": i, "j": j, "matrix_id": matrix_id}
                )
                task_count += 1

        if task_count == 0:
            self.logger.info(f"All matrix cells for {matrix_id} already completed")
            return

        self.logger.info(f"Executing {task_count} matrix cells using {self.max_workers} dedicated workers")

        # Start worker threads - each bound to a specific game worker
        self.logger.debug("Starting worker threads")
        workers = []
        for worker_id in range(self.max_workers):
            worker = Thread(target=self._worker_thread, args=(worker_id, task_queue))
            worker.start()
            workers.append(worker)

        self.logger.debug("Waiting for tasks to complete")
        task_queue.join()
        self.logger.debug("Workers finished")
        for worker in workers:
            worker.join()

        self.logger.info(f"Completed matrix evaluation for {matrix_id}")

    def evaluate_all_matrices(self) -> dict:
        """Evaluate vs matrix between the two players."""