research/problems/cloudcast/evaluator.py

#!/usr/bin/env python3
import argparse
import importlib.util
import json
import os
import sys
import tempfile
from pathlib import Path
from types import ModuleType
from typing import Any, Dict, List, Tuple

HERE = Path(__file__).resolve().parent
RESOURCES = HERE / "resources"
SPEC_PATH = RESOURCES / "submission_spec.json"
OUTPUT_PROGRAM = HERE / "output_program.py"

sys.path.insert(0, str(RESOURCES))

from simulator import BCSimulator  # noqa: E402
from utils import make_nx_graph  # noqa: E402


def load_solution_module(solution_path: Path) -> ModuleType:
    if not solution_path.exists():
        raise FileNotFoundError(f"solution.py not found at {solution_path}")
    spec = importlib.util.spec_from_file_location("submitted_solution", solution_path)
    if spec is None or spec.loader is None:
        raise ImportError(f"Failed to load spec for {solution_path}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


def materialize_program(result: Any) -> Path:
    if isinstance(result, dict):
        if "program_path" in result:
            candidate = Path(result["program_path"]).expanduser()
            if not candidate.exists():
                raise FileNotFoundError(f"Provided program_path does not exist: {candidate}")
            return candidate
        if "code" in result:
            OUTPUT_PROGRAM.write_text(result["code"], encoding="utf-8")
            return OUTPUT_PROGRAM
    if isinstance(result, str):
        # treat as code snippet
        OUTPUT_PROGRAM.write_text(result, encoding="utf-8")
        return OUTPUT_PROGRAM
    raise TypeError("Solution.solve must return dict with 'code' or 'program_path', or a raw code string.")


def load_program_module(program_path: Path) -> ModuleType:
    spec = importlib.util.spec_from_file_location("candidate_program", program_path)
    if spec is None or spec.loader is None:
        raise ImportError(f"Failed to load candidate program from {program_path}")
    module = importlib.util.module_from_spec(spec)
    spec.loader.exec_module(module)
    return module


def evaluate_search_algorithm(program_module: ModuleType, config_files: List[Path], num_vms: int) -> Dict[str, Any]:
    if not hasattr(program_module, "search_algorithm"):
        return {
            "score": 0.0,
            "combined_score": 0.0,
            "runs_successfully": 0.0,
            "error": "Missing search_algorithm function",
        }

    search_algorithm = getattr(program_module, "search_algorithm")
    total_cost = 0.0
    total_transfer_time = 0.0
    successful = 0

    with tempfile.TemporaryDirectory() as temp_dir:
        original_cwd = os.getcwd()
        os.chdir(temp_dir)
        try:
            cost_csv = RESOURCES / "profiles" / "cost.csv"
            throughput_csv = RESOURCES / "profiles" / "throughput.csv"

            for config_path in config_files:
                config = json.loads(config_path.read_text(encoding="utf-8"))
                config_name = config_path.stem

                graph = make_nx_graph(
                    cost_path=str(cost_csv),
                    throughput_path=str(throughput_csv),
                    num_vms=num_vms,
                )

                bc_topology = search_algorithm(
                    config["source_node"],
                    config["dest_nodes"],
                    graph,
                    config["num_partitions"],
                )

                bc_topology.set_num_partitions(config["num_partitions"])

                simulator = BCSimulator(num_vms=num_vms, output_dir="evals")
                transfer_time, cost = simulator.evaluate_path(bc_topology, config)

                total_cost += cost
                total_transfer_time += transfer_time
                successful += 1
        finally:
            os.chdir(original_cwd)

    if successful == 0:
        return {
            "score": 0.0,
            "combined_score": 0.0,
            "runs_successfully": 0.0,
            "error": "No configurations evaluated successfully",
        }

    cost_score = 1.0 / (1.0 + total_cost)
    combined_score = cost_score
    score = combined_score * 100

    return {
        "score": score,
        "combined_score": combined_score,
        "runs_successfully": 1.0,
        "cost_score": cost_score,
        "time_score": time_score,
        "total_cost": total_cost,
        "total_transfer_time": total_transfer_time,
        "successful_runs": successful,
    }


class Evaluator:
    def __init__(self):
        """Initialize evaluator with hard-coded environment setup and load test traces"""
        # Hard code in evaluator, env setup (done in prepare_env.py)
        self.spec_path = SPEC_PATH
        self.output_program = OUTPUT_PROGRAM
        
        # Load test traces (config files)
        spec = json.loads(self.spec_path.read_text(encoding="utf-8"))
        self.config_files = [RESOURCES / Path(cfg) for cfg in spec["config_files"]]
        self.num_vms = spec["num_vms"]

    def evaluate(self, solution):
        """
        Evaluate the solution using the loaded traces
        Args:
            solution: Solution instance with solve() method
        Returns:
            Dict with score and other metrics
        """
        # Call solution.solve() with trace config and traces
        result = solution.solve(str(self.spec_path))
        program_path = materialize_program(result)
        program_module = load_program_module(program_path)

        # Calculate score using the search algorithm
        metrics = evaluate_search_algorithm(program_module, self.config_files, self.num_vms)
        return metrics


def evaluate(solution_path: Path, spec_path: Path) -> Dict[str, Any]:
    """Legacy function for backward compatibility"""
    solution_module = load_solution_module(solution_path)
    if not hasattr(solution_module, "Solution"):
        raise AttributeError("solution.py must define a Solution class with a solve method")
    solution_obj = solution_module.Solution()
    if not hasattr(solution_obj, "solve"):
        raise AttributeError("Solution class must define a solve(spec_path: str) method")

    spec = json.loads(spec_path.read_text(encoding="utf-8"))
    result = solution_obj.solve(str(spec_path))
    program_path = materialize_program(result)
    program_module = load_program_module(program_path)

    config_files = [RESOURCES / Path(cfg) for cfg in spec["config_files"]]
    metrics = evaluate_search_algorithm(program_module, config_files, spec["num_vms"])
    return metrics


def main() -> None:
    parser = argparse.ArgumentParser(description="Evaluate cloudcast broadcast optimizer")
    parser.add_argument("--solution", default="../../execution_env/solution_env/solution.py")
    parser.add_argument("--spec", default=str(SPEC_PATH))
    parser.add_argument("--out", default="results.json")
    args = parser.parse_args()

    solution_path = Path(args.solution).resolve()
    spec_path = Path(args.spec).resolve()
    out_path = Path(args.out).resolve()
    try:
        module = load_solution_module(solution_path)
        
        # Use new Solution class format
        solution_class = getattr(module, "Solution", None)
        if solution_class is None:
            raise AttributeError("Solution class not found in solution.py")
        
        print("[evaluator] Using Solution class format", file=sys.stderr)
        evaluator = Evaluator()
        solution = solution_class()
        payload = evaluator.evaluate(solution)
        
        out_path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
        print(json.dumps(payload))
    except Exception as exc:
        error_payload = {"score": 0.0, "error": str(exc)}
        out_path.write_text(json.dumps(error_payload, indent=2), encoding="utf-8")
        print(json.dumps(error_payload))
        raise


if __name__ == "__main__":
    main()