AINativeBench / data /processed /RQ2 /SQLAssistant-A2A /plot_agent_time_share_bars.py

王子睿

restructure + add files

8c10cf2 11 months ago

18.2 kB

#!/usr/bin/env python3

"""Plot per-model agent LLM+Tool time share across models for *mix projects.
Usage:
    python plot_agent_time_share_bars.py
This script processes a single project directory. By default it uses the
current working directory, or a directory specified via --project-dir. It
reads the "agent_llm_tool_breakdown_by_model.csv" in that directory and
generates one stacked bar chart:
- One figure per project (per CSV).
- In each figure there are up to 7 bars, one per model, with fixed
  left-to-right order:
    GPT-5, GPT-4o-mini, DeepSeek-V3-1, DeepSeek-R1,
    Gemini-2.5-flash, Gemini-2.5-flash-nothinking, Qwen3-235b.
- Each bar is stacked by agents, using total_agent_llm_tool_time_ms summed over
  all occurrences for that (model, agent_name).
- Within a bar, these agents are normalized so that the total bar height is
  1.0 (Latency Breakdown from 0 to 1).
- Each agent segment is annotated with its absolute time in ms.
The resulting PDF is written into each project folder as
"agent_time_share_bars.pdf".
"""

import argparse
import csv
from collections import defaultdict
from pathlib import Path
from typing import Dict, List, Optional
import math

import matplotlib.pyplot as plt
from matplotlib.ticker import PercentFormatter

# Use a serif font similar to "New Roma time" for all text
plt.rcParams["font.family"] = "Times New Roman"
# Ensure mathtext (used for bold slash) also renders in Times New Roman style
plt.rcParams["mathtext.fontset"] = "custom"
plt.rcParams["mathtext.rm"] = "Times New Roman"
plt.rcParams["mathtext.it"] = "Times New Roman:italic"
plt.rcParams["mathtext.bf"] = "Times New Roman:bold"

# Fixed model order (must match the names used in the CSV files)
MODEL_ORDER: List[str] = [
    "GPT-5",
    "GPT-4o-mini",
    "DeepSeek-V3-1",
    "DeepSeek-R1",
    "Gemini-2.5-flash",
    "Gemini-2.5-flash-nothinking",
    "Qwen3-235b",
]

# Optional display labels
MODEL_LABELS: Dict[str, str] = {
    "GPT-5": "GPT-5",
    "GPT-4o-mini": "GPT-4o-mini",
    "DeepSeek-V3-1": "DeepSeek-V3.1",
    "DeepSeek-R1": "DeepSeek-R1",
    "Gemini-2.5-flash": "Gemini-2.5",
    "Gemini-2.5-flash-nothinking": "Gemini-2.5-NT",
    "Qwen3-235b": "Qwen3-235b",
}

# Color cycle for agents (pastel, low-saturation colors)
AGENT_COLOR_CYCLE: List[str] = [
    "#88a4c9",  # light blue
    "#ff8696",  # light pink
    "#bbe6dd",  # light teal
    "#fde8b2",  # light cream
    "#c7b9e2",  # light purple
    "#f4b6c2",  # light rose
]


def find_agent_breakdown_csvs(root: Path) -> List[Path]:
    """Find all agent_llm_tool_breakdown_by_model.csv under first-level subdirs."""

    csv_paths: List[Path] = []
    for sub in root.iterdir():
        if not sub.is_dir():
            continue
        candidate = sub / "agent_llm_tool_breakdown_by_model.csv"
        if candidate.exists():
            csv_paths.append(candidate)
    csv_paths.sort()
    return csv_paths


def load_agent_totals(csv_path: Path) -> Dict[str, Dict[str, float]]:
    """Load per-model per-agent total_agent_llm_tool_time_ms from CSV.
    Returns:
        data[model][agent_name] = total_agent_llm_tool_time_ms
    """

    data: Dict[str, Dict[str, float]] = defaultdict(dict)
    with csv_path.open("r", encoding="utf-8", newline="") as f:
        reader = csv.DictReader(f)
        for row in reader:
            model = (row.get("model") or "").strip()
            agent_name = (row.get("agent_name") or "").strip()
            if not model or not agent_name:
                continue
            try:
                val = float(row.get("total_agent_llm_tool_time_ms", "0") or 0)
            except ValueError:
                val = 0.0
            data[model][agent_name] = data[model].get(agent_name, 0.0) + val
    return data


def parse_agent_map_args(map_args: List[str]) -> Dict[str, str]:
    """Parse --agent-map raw:new arguments into a mapping dictionary."""

    mapping: Dict[str, str] = {}
    for item in map_args:
        if ":" not in item:
            continue
        raw, mapped = item.split(":", 1)
        raw = raw.strip()
        mapped = mapped.strip()
        if raw and mapped:
            mapping[raw] = mapped
    return mapping


def apply_agent_mapping(
    model_to_agents: Dict[str, Dict[str, float]],
    agent_name_map: Dict[str, str],
) -> Dict[str, Dict[str, float]]:
    """Aggregate agents according to a name mapping."""

    if not agent_name_map:
        return model_to_agents

    mapped: Dict[str, Dict[str, float]] = {}
    for model, agents in model_to_agents.items():
        agg: Dict[str, float] = defaultdict(float)
        for raw_agent, val in agents.items():
            display = agent_name_map.get(raw_agent, raw_agent)
            agg[display] += val
        mapped[model] = dict(agg)
    return mapped


def compute_percent_labels(shares: List[float]) -> List[float]:
    total = sum(shares)
    if total <= 0.0:
        return [0.0 for _ in shares]
    raw = [(s / total) * 10000.0 for s in shares]
    floors = [int(math.floor(r)) for r in raw]
    floor_sum = sum(floors)
    diff = 10000 - floor_sum
    remainders = [r - f for r, f in zip(raw, floors)]
    order = sorted(range(len(shares)), key=lambda i: remainders[i], reverse=True)
    if diff > 0:
        for k in range(min(diff, len(order))):
            floors[order[k]] += 1
    elif diff < 0:
        for k in range(min(-diff, len(order))):
            floors[order[-1 - k]] -= 1
    return [v / 100.0 for v in floors]


def plot_agent_time_share_bars(
    project_name: str,
    csv_path: Path,
    model_to_agents: Dict[str, Dict[str, float]],
    out_dir: Path,
    agent_order: Optional[List[str]] = None,
) -> None:
    """Plot stacked agent time-share bars for one project across all models.
    - One bar per model (7 bars total, some may be missing if no data).
    - Each bar is stacked by agents, normalized so total height is 1.0.
    - Each segment is annotated with its absolute ms value.
    """

    # Collect the union of agents across all models
    agent_names = set()
    for agents in model_to_agents.values():
        agent_names.update(agents.keys())
    if not agent_names:
        return

    # Determine agent order.
    # If an explicit order is provided (after mapping), use it (and append any
    # missing agents by total time). Otherwise, order agents by total time
    # across all models (descending).
    def _agent_total(agent: str) -> float:
        return sum(model_to_agents.get(m, {}).get(agent, 0.0) for m in MODEL_ORDER)

    if agent_order:
        known = list(agent_order)
        missing = [a for a in agent_names if a not in known]
        if missing:
            missing_sorted = sorted(missing, key=_agent_total, reverse=True)
            agent_order = known + missing_sorted
    else:
        agent_order = sorted(agent_names, key=_agent_total, reverse=True)

    # Map agents to colors (cycle if more agents than colors)
    agent_colors: Dict[str, str] = {}
    for idx, agent in enumerate(agent_order):
        agent_colors[agent] = AGENT_COLOR_CYCLE[idx % len(AGENT_COLOR_CYCLE)]

    x = list(range(len(MODEL_ORDER)))

    # Prepare per-agent shares and raw ms per model
    shares_by_agent: Dict[str, List[float]] = {a: [] for a in agent_order}
    ms_by_agent: Dict[str, List[float]] = {a: [] for a in agent_order}

    for model in MODEL_ORDER:
        agents = model_to_agents.get(model, {})
        ms_vals = [float(agents.get(a, 0.0) or 0.0) for a in agent_order]
        ks_vals = [v / 1000000.0 for v in ms_vals]
        for agent, val in zip(agent_order, ks_vals):
            shares_by_agent[agent].append(val)
            ms_by_agent[agent].append(val)

    max_total_s = 0.0
    for idx in range(len(MODEL_ORDER)):
        total = sum(shares_by_agent[agent][idx] for agent in agent_order)
        if total > max_total_s:
            max_total_s = total

    fig, ax = plt.subplots(figsize=(7.5, 5))

    # Build stacked bars
    bottoms = [0.0 for _ in x]
    bar_handles: Dict[str, any] = {}
    bar_width = 0.98
    for agent in agent_order:
        heights = shares_by_agent[agent]
        color = agent_colors[agent]
        bars = ax.bar(
            x,
            heights,
            bottom=bottoms,
            color=color,
            edgecolor="none",
            width=bar_width,
        )
        bar_handles[agent] = bars
        bottoms = [b + h for b, h in zip(bottoms, heights)]

    # Reduce inner left/right whitespace inside the axes
    margin = (1.0 - bar_width) / 2.0
    ax.set_xlim(-0.5 + margin, len(MODEL_ORDER) - 0.5 - margin)

    ax.yaxis.grid(True, linestyle="--", alpha=0.3, linewidth=0.8)

    # Annotate percentage values inside each agent's bar segment
    # Estimate minimum height needed for a label (fontsize 10)
    # As a heuristic, we use ~2.5% of the max total as the minimum height
    min_height_for_label = max_total_s * 0.02
    # Minimum gap between labels to avoid overlap
    min_gap = max_total_s * 0.03

    # Process each model's bar separately
    for model_idx in range(len(MODEL_ORDER)):
        label_entries = []  # [y_center, x_center, percent_text, agent_idx]

        for agent_idx, agent in enumerate(agent_order):
            share_val = shares_by_agent[agent][model_idx]
            if share_val <= 0.0:
                continue

            # Filter: only show label if segment height is sufficient
            if share_val < min_height_for_label:
                continue

            # Calculate total for this model to compute percentage
            total_for_model = sum(shares_by_agent[a][model_idx] for a in agent_order)
            if total_for_model <= 0.0:
                continue

            percent = (share_val / total_for_model) * 100.0

            # Calculate the exact vertical center position of this agent's segment
            # Bars are stacked from bottom to top following agent_order
            # Bottom edge: sum of all previous agents' heights
            segment_bottom = sum(
                shares_by_agent[a][model_idx] for a in agent_order[:agent_idx]
            )
            # Top edge: bottom + current agent's height
            segment_top = segment_bottom + share_val
            # Vertical center: exactly in the middle
            y_center = (segment_bottom + segment_top) / 2.0

            # Calculate the exact horizontal center position
            bar = bar_handles[agent][model_idx]
            x_center = bar.get_x() + bar.get_width() / 2.0

            percent_text = f"${percent:.1f}\\%$"
            label_entries.append([y_center, x_center, percent_text, agent_idx])

        # Apply greedy spacing to reduce label overlap
        if len(label_entries) > 1:
            max_iterations = 50
            for _ in range(max_iterations):
                label_entries.sort(key=lambda e: e[0])
                changed = False
                for i in range(1, len(label_entries)):
                    y_prev = label_entries[i - 1][0]
                    y_curr = label_entries[i][0]
                    if y_curr - y_prev < min_gap:
                        needed = min_gap - (y_curr - y_prev)
                        shift_up = needed / 3.0
                        shift_down = 2.0 * shift_up
                        label_entries[i - 1][0] = y_prev - shift_down
                        label_entries[i][0] = y_curr + shift_up
                        changed = True
                if not changed:
                    break

        # Draw all labels for this model
        for y_center, x_center, percent_text, agent_idx in label_entries:
            ax.text(
                x_center,
                y_center,
                percent_text,
                ha="center",
                va="center",
                fontsize=10,
                color="black",
                fontweight="bold",
            )

    # X axis labels in fixed order
    tick_labels = [MODEL_LABELS.get(m, m) for m in MODEL_ORDER]
    ax.set_xticks(x)
    ax.set_xticklabels(tick_labels, rotation=0, ha="center")

    # Set tick label fonts: smaller on x axis to reduce overlap, keep y axis larger
    ax.tick_params(axis="x", labelsize=10)
    ax.tick_params(axis="y", labelsize=14)

    ax.set_ylim(0.0, max_total_s * 1.15)
    ax.set_ylabel("Latency Breakdown(×10³s)", fontsize=18)

    # Add total time labels on top of each bar
    for idx in range(len(MODEL_ORDER)):
        total_time = sum(shares_by_agent[agent][idx] for agent in agent_order)
        if total_time > 0:
            offset = max_total_s * 0.02
            label_y = total_time + offset
            ax.text(
                idx,
                label_y,
                f"{total_time:.2f}",
                ha="center",
                va="bottom",
                fontsize=14,
                fontweight="bold",
            )

    # Legend at top, horizontal, with inline "Agent" label.
    # First legend: a standalone text label "Agent".
    heading_handle = plt.Rectangle((0, 0), 1, 1, facecolor="none", edgecolor="none")
    legend_anchor_y = 1.06
    heading_legend_x = -0.08
    heading_legend = ax.legend(
        [heading_handle],
        ["Agent"],
        fontsize=12,
        loc="center left",
        bbox_to_anchor=(heading_legend_x, legend_anchor_y),
        ncol=1,
        frameon=False,
        columnspacing=0.8,
        handletextpad=0.5,
    )

    # Second legend: grouped entries for individual agents.
    # Legend order follows bar stack order from top to bottom
    legend_order = list(reversed(agent_order))

    # Create row-major order list: [item1, item2, dummy, item3, item4, item5]
    row_order = []
    for agent in legend_order:
        row_order.append((agent, agent_colors[agent]))
    # Add dummy placeholder at position 2 (after first 2 items)
    row_order.insert(2, (None, None))

    # Convert row-major to column-major for matplotlib legend (ncol=3)
    # Row-major: [0,1,2], [3,4,5] -> Column-major: [0,3], [1,4], [2,5]
    handles = []
    labels = []
    nrows = 2
    ncols = 3
    for col in range(ncols):
        for row in range(nrows):
            idx = row * ncols + col
            if idx < len(row_order):
                agent, color = row_order[idx]
                if agent is None:
                    handles.append(
                        plt.Rectangle((0, 0), 1, 1, facecolor="none", edgecolor="none")
                    )
                    labels.append("")
                else:
                    handles.append(
                        plt.Rectangle((0, 0), 1, 1, facecolor=color, edgecolor="none")
                    )
                    labels.append(agent)

    # Use 3 columns to create 2-row layout: first row has 2 items + 1 dummy, second row has 3 items
    ncols_agents = 3

    agent_legend_x = 0.1
    agent_legend = ax.legend(
        handles,
        labels,
        fontsize=12,
        loc="center left",
        bbox_to_anchor=(agent_legend_x, legend_anchor_y),
        ncol=ncols_agents,
        frameon=False,
        columnspacing=0.8,
        handletextpad=0.5,
    )

    # Make sure both legends are drawn
    ax.add_artist(heading_legend)

    legend_texts = heading_legend.get_texts()
    if legend_texts:
        legend_texts[0].set_fontsize(18)

    fig.subplots_adjust(left=0.09, right=0.999, bottom=0.167, top=0.88)

    out_file = out_dir / f"{project_name}_agent_time_share_bars.pdf"
    fig.savefig(out_file, dpi=200, bbox_inches="tight", pad_inches=0.02)
    plt.close(fig)
    print(f"saved figure: {out_file}")


def parse_args() -> argparse.Namespace:
    """Parse command-line arguments."""

    parser = argparse.ArgumentParser(
        description="Plot stacked agent time-share bars for a single project.",
    )
    parser.add_argument(
        "--project-dir",
        type=str,
        default=".",
        help=(
            "Project directory containing agent_llm_tool_breakdown_by_model.csv "
            "(default: current working directory)."
        ),
    )
    parser.add_argument(
        "--csv",
        type=str,
        default=None,
        help=(
            "Path to agent_llm_tool_breakdown_by_model.csv. "
            "If not provided, defaults to <project-dir>/agent_llm_tool_breakdown_by_model.csv."
        ),
    )
    parser.add_argument(
        "--agent-order",
        type=str,
        default=None,
        help=(
            "Comma-separated list of agent display names from TOP to BOTTOM. "
            "The legend (left-to-right) will follow the same top-to-bottom order."
        ),
    )
    parser.add_argument(
        "--agent-map",
        type=str,
        action="append",
        default=[],
        help=(
            "Agent name mapping in the form 'raw_name:mapped_name'. "
            "Can be specified multiple times."
        ),
    )
    return parser.parse_args()


def main() -> None:
    args = parse_args()

    project_dir = Path(args.project_dir).resolve()
    if not project_dir.is_dir():
        print(f"project_dir {project_dir} is not a directory")
        return

    if args.csv:
        csv_path = Path(args.csv).resolve()
    else:
        csv_path = project_dir / "agent_llm_tool_breakdown_by_model.csv"

    if not csv_path.exists():
        print(f"{csv_path} not found")
        return

    project_name = project_dir.name
    print(f"processing {csv_path} (project={project_name})")

    model_to_agents_raw = load_agent_totals(csv_path)
    if not model_to_agents_raw:
        print(f"  no agent data in {csv_path}")
        return

    agent_name_map = parse_agent_map_args(args.agent_map)
    model_to_agents = apply_agent_mapping(model_to_agents_raw, agent_name_map)

    agent_order: Optional[List[str]] = None
    if args.agent_order:
        order_top_to_bottom = [
            name.strip() for name in args.agent_order.split(",") if name.strip()
        ]
        if order_top_to_bottom:
            # Internally we stack from bottom to top, so reverse the
            # user-specified top-to-bottom order.
            agent_order = list(reversed(order_top_to_bottom))

    plot_agent_time_share_bars(
        project_name,
        csv_path,
        model_to_agents,
        project_dir,
        agent_order=agent_order,
    )


if __name__ == "__main__":
    main()

	#!/usr/bin/env python3

	"""Plot per-model agent LLM+Tool time share across models for *mix projects.

	Usage:
	python plot_agent_time_share_bars.py

	This script processes a single project directory. By default it uses the
	current working directory, or a directory specified via --project-dir. It
	reads the "agent_llm_tool_breakdown_by_model.csv" in that directory and
	generates one stacked bar chart:

	- One figure per project (per CSV).
	- In each figure there are up to 7 bars, one per model, with fixed
	left-to-right order:
	GPT-5, GPT-4o-mini, DeepSeek-V3-1, DeepSeek-R1,
	Gemini-2.5-flash, Gemini-2.5-flash-nothinking, Qwen3-235b.
	- Each bar is stacked by agents, using total_agent_llm_tool_time_ms summed over
	all occurrences for that (model, agent_name).
	- Within a bar, these agents are normalized so that the total bar height is
	1.0 (Latency Breakdown from 0 to 1).
	- Each agent segment is annotated with its absolute time in ms.

	The resulting PDF is written into each project folder as
	"agent_time_share_bars.pdf".
	"""

	import argparse
	import csv
	from collections import defaultdict
	from pathlib import Path
	from typing import Dict, List, Optional
	import math

	import matplotlib.pyplot as plt
	from matplotlib.ticker import PercentFormatter

	# Use a serif font similar to "New Roma time" for all text
	plt.rcParams["font.family"] = "Times New Roman"
	# Ensure mathtext (used for bold slash) also renders in Times New Roman style
	plt.rcParams["mathtext.fontset"] = "custom"
	plt.rcParams["mathtext.rm"] = "Times New Roman"
	plt.rcParams["mathtext.it"] = "Times New Roman:italic"
	plt.rcParams["mathtext.bf"] = "Times New Roman:bold"

	# Fixed model order (must match the names used in the CSV files)
	MODEL_ORDER: List[str] = [
	"GPT-5",
	"GPT-4o-mini",
	"DeepSeek-V3-1",
	"DeepSeek-R1",
	"Gemini-2.5-flash",
	"Gemini-2.5-flash-nothinking",
	"Qwen3-235b",
	]

	# Optional display labels
	MODEL_LABELS: Dict[str, str] = {
	"GPT-5": "GPT-5",
	"GPT-4o-mini": "GPT-4o-mini",
	"DeepSeek-V3-1": "DeepSeek-V3.1",
	"DeepSeek-R1": "DeepSeek-R1",
	"Gemini-2.5-flash": "Gemini-2.5",
	"Gemini-2.5-flash-nothinking": "Gemini-2.5-NT",
	"Qwen3-235b": "Qwen3-235b",
	}

	# Color cycle for agents (pastel, low-saturation colors)
	AGENT_COLOR_CYCLE: List[str] = [
	"#88a4c9", # light blue
	"#ff8696", # light pink
	"#bbe6dd", # light teal
	"#fde8b2", # light cream
	"#c7b9e2", # light purple
	"#f4b6c2", # light rose
	]


	def find_agent_breakdown_csvs(root: Path) -> List[Path]:
	"""Find all agent_llm_tool_breakdown_by_model.csv under first-level subdirs."""

	csv_paths: List[Path] = []
	for sub in root.iterdir():
	if not sub.is_dir():
	continue
	candidate = sub / "agent_llm_tool_breakdown_by_model.csv"
	if candidate.exists():
	csv_paths.append(candidate)
	csv_paths.sort()
	return csv_paths


	def load_agent_totals(csv_path: Path) -> Dict[str, Dict[str, float]]:
	"""Load per-model per-agent total_agent_llm_tool_time_ms from CSV.

	Returns:
	data[model][agent_name] = total_agent_llm_tool_time_ms
	"""

	data: Dict[str, Dict[str, float]] = defaultdict(dict)
	with csv_path.open("r", encoding="utf-8", newline="") as f:
	reader = csv.DictReader(f)
	for row in reader:
	model = (row.get("model") or "").strip()
	agent_name = (row.get("agent_name") or "").strip()
	if not model or not agent_name:
	continue
	try:
	val = float(row.get("total_agent_llm_tool_time_ms", "0") or 0)
	except ValueError:
	val = 0.0
	data[model][agent_name] = data[model].get(agent_name, 0.0) + val
	return data


	def parse_agent_map_args(map_args: List[str]) -> Dict[str, str]:
	"""Parse --agent-map raw:new arguments into a mapping dictionary."""

	mapping: Dict[str, str] = {}
	for item in map_args:
	if ":" not in item:
	continue
	raw, mapped = item.split(":", 1)
	raw = raw.strip()
	mapped = mapped.strip()
	if raw and mapped:
	mapping[raw] = mapped
	return mapping


	def apply_agent_mapping(
	model_to_agents: Dict[str, Dict[str, float]],
	agent_name_map: Dict[str, str],
	) -> Dict[str, Dict[str, float]]:
	"""Aggregate agents according to a name mapping."""

	if not agent_name_map:
	return model_to_agents

	mapped: Dict[str, Dict[str, float]] = {}
	for model, agents in model_to_agents.items():
	agg: Dict[str, float] = defaultdict(float)
	for raw_agent, val in agents.items():
	display = agent_name_map.get(raw_agent, raw_agent)
	agg[display] += val
	mapped[model] = dict(agg)
	return mapped


	def compute_percent_labels(shares: List[float]) -> List[float]:
	total = sum(shares)
	if total <= 0.0:
	return [0.0 for _ in shares]
	raw = [(s / total) * 10000.0 for s in shares]
	floors = [int(math.floor(r)) for r in raw]
	floor_sum = sum(floors)
	diff = 10000 - floor_sum
	remainders = [r - f for r, f in zip(raw, floors)]
	order = sorted(range(len(shares)), key=lambda i: remainders[i], reverse=True)
	if diff > 0:
	for k in range(min(diff, len(order))):
	floors[order[k]] += 1
	elif diff < 0:
	for k in range(min(-diff, len(order))):
	floors[order[-1 - k]] -= 1
	return [v / 100.0 for v in floors]


	def plot_agent_time_share_bars(
	project_name: str,
	csv_path: Path,
	model_to_agents: Dict[str, Dict[str, float]],
	out_dir: Path,
	agent_order: Optional[List[str]] = None,
	) -> None:
	"""Plot stacked agent time-share bars for one project across all models.

	- One bar per model (7 bars total, some may be missing if no data).
	- Each bar is stacked by agents, normalized so total height is 1.0.
	- Each segment is annotated with its absolute ms value.
	"""

	# Collect the union of agents across all models
	agent_names = set()
	for agents in model_to_agents.values():
	agent_names.update(agents.keys())
	if not agent_names:
	return

	# Determine agent order.
	# If an explicit order is provided (after mapping), use it (and append any
	# missing agents by total time). Otherwise, order agents by total time
	# across all models (descending).
	def _agent_total(agent: str) -> float:
	return sum(model_to_agents.get(m, {}).get(agent, 0.0) for m in MODEL_ORDER)

	if agent_order:
	known = list(agent_order)
	missing = [a for a in agent_names if a not in known]
	if missing:
	missing_sorted = sorted(missing, key=_agent_total, reverse=True)
	agent_order = known + missing_sorted
	else:
	agent_order = sorted(agent_names, key=_agent_total, reverse=True)

	# Map agents to colors (cycle if more agents than colors)
	agent_colors: Dict[str, str] = {}
	for idx, agent in enumerate(agent_order):
	agent_colors[agent] = AGENT_COLOR_CYCLE[idx % len(AGENT_COLOR_CYCLE)]

	x = list(range(len(MODEL_ORDER)))

	# Prepare per-agent shares and raw ms per model
	shares_by_agent: Dict[str, List[float]] = {a: [] for a in agent_order}
	ms_by_agent: Dict[str, List[float]] = {a: [] for a in agent_order}

	for model in MODEL_ORDER:
	agents = model_to_agents.get(model, {})
	ms_vals = [float(agents.get(a, 0.0) or 0.0) for a in agent_order]
	ks_vals = [v / 1000000.0 for v in ms_vals]
	for agent, val in zip(agent_order, ks_vals):
	shares_by_agent[agent].append(val)
	ms_by_agent[agent].append(val)

	max_total_s = 0.0
	for idx in range(len(MODEL_ORDER)):
	total = sum(shares_by_agent[agent][idx] for agent in agent_order)
	if total > max_total_s:
	max_total_s = total

	fig, ax = plt.subplots(figsize=(7.5, 5))

	# Build stacked bars
	bottoms = [0.0 for _ in x]
	bar_handles: Dict[str, any] = {}
	bar_width = 0.98
	for agent in agent_order:
	heights = shares_by_agent[agent]
	color = agent_colors[agent]
	bars = ax.bar(
	x,
	heights,
	bottom=bottoms,
	color=color,
	edgecolor="none",
	width=bar_width,
	)
	bar_handles[agent] = bars
	bottoms = [b + h for b, h in zip(bottoms, heights)]

	# Reduce inner left/right whitespace inside the axes
	margin = (1.0 - bar_width) / 2.0
	ax.set_xlim(-0.5 + margin, len(MODEL_ORDER) - 0.5 - margin)

	ax.yaxis.grid(True, linestyle="--", alpha=0.3, linewidth=0.8)

	# Annotate percentage values inside each agent's bar segment
	# Estimate minimum height needed for a label (fontsize 10)
	# As a heuristic, we use ~2.5% of the max total as the minimum height
	min_height_for_label = max_total_s * 0.02
	# Minimum gap between labels to avoid overlap
	min_gap = max_total_s * 0.03

	# Process each model's bar separately
	for model_idx in range(len(MODEL_ORDER)):
	label_entries = [] # [y_center, x_center, percent_text, agent_idx]

	for agent_idx, agent in enumerate(agent_order):
	share_val = shares_by_agent[agent][model_idx]
	if share_val <= 0.0:
	continue

	# Filter: only show label if segment height is sufficient
	if share_val < min_height_for_label:
	continue

	# Calculate total for this model to compute percentage
	total_for_model = sum(shares_by_agent[a][model_idx] for a in agent_order)
	if total_for_model <= 0.0:
	continue

	percent = (share_val / total_for_model) * 100.0

	# Calculate the exact vertical center position of this agent's segment
	# Bars are stacked from bottom to top following agent_order
	# Bottom edge: sum of all previous agents' heights
	segment_bottom = sum(
	shares_by_agent[a][model_idx] for a in agent_order[:agent_idx]
	)
	# Top edge: bottom + current agent's height
	segment_top = segment_bottom + share_val
	# Vertical center: exactly in the middle
	y_center = (segment_bottom + segment_top) / 2.0

	# Calculate the exact horizontal center position
	bar = bar_handles[agent][model_idx]
	x_center = bar.get_x() + bar.get_width() / 2.0

	percent_text = f"${percent:.1f}\\%$"
	label_entries.append([y_center, x_center, percent_text, agent_idx])

	# Apply greedy spacing to reduce label overlap
	if len(label_entries) > 1:
	max_iterations = 50
	for _ in range(max_iterations):
	label_entries.sort(key=lambda e: e[0])
	changed = False
	for i in range(1, len(label_entries)):
	y_prev = label_entries[i - 1][0]
	y_curr = label_entries[i][0]
	if y_curr - y_prev < min_gap:
	needed = min_gap - (y_curr - y_prev)
	shift_up = needed / 3.0
	shift_down = 2.0 * shift_up
	label_entries[i - 1][0] = y_prev - shift_down
	label_entries[i][0] = y_curr + shift_up
	changed = True
	if not changed:
	break

	# Draw all labels for this model
	for y_center, x_center, percent_text, agent_idx in label_entries:
	ax.text(
	x_center,
	y_center,
	percent_text,
	ha="center",
	va="center",
	fontsize=10,
	color="black",
	fontweight="bold",
	)

	# X axis labels in fixed order
	tick_labels = [MODEL_LABELS.get(m, m) for m in MODEL_ORDER]
	ax.set_xticks(x)
	ax.set_xticklabels(tick_labels, rotation=0, ha="center")

	# Set tick label fonts: smaller on x axis to reduce overlap, keep y axis larger
	ax.tick_params(axis="x", labelsize=10)
	ax.tick_params(axis="y", labelsize=14)

	ax.set_ylim(0.0, max_total_s * 1.15)
	ax.set_ylabel("Latency Breakdown(×10³s)", fontsize=18)

	# Add total time labels on top of each bar
	for idx in range(len(MODEL_ORDER)):
	total_time = sum(shares_by_agent[agent][idx] for agent in agent_order)
	if total_time > 0:
	offset = max_total_s * 0.02
	label_y = total_time + offset
	ax.text(
	idx,
	label_y,
	f"{total_time:.2f}",
	ha="center",
	va="bottom",
	fontsize=14,
	fontweight="bold",
	)

	# Legend at top, horizontal, with inline "Agent" label.
	# First legend: a standalone text label "Agent".
	heading_handle = plt.Rectangle((0, 0), 1, 1, facecolor="none", edgecolor="none")
	legend_anchor_y = 1.06
	heading_legend_x = -0.08
	heading_legend = ax.legend(
	[heading_handle],
	["Agent"],
	fontsize=12,
	loc="center left",
	bbox_to_anchor=(heading_legend_x, legend_anchor_y),
	ncol=1,
	frameon=False,
	columnspacing=0.8,
	handletextpad=0.5,
	)

	# Second legend: grouped entries for individual agents.
	# Legend order follows bar stack order from top to bottom
	legend_order = list(reversed(agent_order))

	# Create row-major order list: [item1, item2, dummy, item3, item4, item5]
	row_order = []
	for agent in legend_order:
	row_order.append((agent, agent_colors[agent]))
	# Add dummy placeholder at position 2 (after first 2 items)
	row_order.insert(2, (None, None))

	# Convert row-major to column-major for matplotlib legend (ncol=3)
	# Row-major: [0,1,2], [3,4,5] -> Column-major: [0,3], [1,4], [2,5]
	handles = []
	labels = []
	nrows = 2
	ncols = 3
	for col in range(ncols):
	for row in range(nrows):
	idx = row * ncols + col
	if idx < len(row_order):
	agent, color = row_order[idx]
	if agent is None:
	handles.append(
	plt.Rectangle((0, 0), 1, 1, facecolor="none", edgecolor="none")
	)
	labels.append("")
	else:
	handles.append(
	plt.Rectangle((0, 0), 1, 1, facecolor=color, edgecolor="none")
	)
	labels.append(agent)

	# Use 3 columns to create 2-row layout: first row has 2 items + 1 dummy, second row has 3 items
	ncols_agents = 3

	agent_legend_x = 0.1
	agent_legend = ax.legend(
	handles,
	labels,
	fontsize=12,
	loc="center left",
	bbox_to_anchor=(agent_legend_x, legend_anchor_y),
	ncol=ncols_agents,
	frameon=False,
	columnspacing=0.8,
	handletextpad=0.5,
	)

	# Make sure both legends are drawn
	ax.add_artist(heading_legend)

	legend_texts = heading_legend.get_texts()
	if legend_texts:
	legend_texts[0].set_fontsize(18)

	fig.subplots_adjust(left=0.09, right=0.999, bottom=0.167, top=0.88)

	out_file = out_dir / f"{project_name}_agent_time_share_bars.pdf"
	fig.savefig(out_file, dpi=200, bbox_inches="tight", pad_inches=0.02)
	plt.close(fig)
	print(f"saved figure: {out_file}")


	def parse_args() -> argparse.Namespace:
	"""Parse command-line arguments."""

	parser = argparse.ArgumentParser(
	description="Plot stacked agent time-share bars for a single project.",
	)
	parser.add_argument(
	"--project-dir",
	type=str,
	default=".",
	help=(
	"Project directory containing agent_llm_tool_breakdown_by_model.csv "
	"(default: current working directory)."
	),
	)
	parser.add_argument(
	"--csv",
	type=str,
	default=None,
	help=(
	"Path to agent_llm_tool_breakdown_by_model.csv. "
	"If not provided, defaults to <project-dir>/agent_llm_tool_breakdown_by_model.csv."
	),
	)
	parser.add_argument(
	"--agent-order",
	type=str,
	default=None,
	help=(
	"Comma-separated list of agent display names from TOP to BOTTOM. "
	"The legend (left-to-right) will follow the same top-to-bottom order."
	),
	)
	parser.add_argument(
	"--agent-map",
	type=str,
	action="append",
	default=[],
	help=(
	"Agent name mapping in the form 'raw_name:mapped_name'. "
	"Can be specified multiple times."
	),
	)
	return parser.parse_args()


	def main() -> None:
	args = parse_args()

	project_dir = Path(args.project_dir).resolve()
	if not project_dir.is_dir():
	print(f"project_dir {project_dir} is not a directory")
	return

	if args.csv:
	csv_path = Path(args.csv).resolve()
	else:
	csv_path = project_dir / "agent_llm_tool_breakdown_by_model.csv"

	if not csv_path.exists():
	print(f"{csv_path} not found")
	return

	project_name = project_dir.name
	print(f"processing {csv_path} (project={project_name})")

	model_to_agents_raw = load_agent_totals(csv_path)
	if not model_to_agents_raw:
	print(f" no agent data in {csv_path}")
	return

	agent_name_map = parse_agent_map_args(args.agent_map)
	model_to_agents = apply_agent_mapping(model_to_agents_raw, agent_name_map)

	agent_order: Optional[List[str]] = None
	if args.agent_order:
	order_top_to_bottom = [
	name.strip() for name in args.agent_order.split(",") if name.strip()
	]
	if order_top_to_bottom:
	# Internally we stack from bottom to top, so reverse the
	# user-specified top-to-bottom order.
	agent_order = list(reversed(order_top_to_bottom))

	plot_agent_time_share_bars(
	project_name,
	csv_path,
	model_to_agents,
	project_dir,
	agent_order=agent_order,
	)


	if __name__ == "__main__":
	main()