diff --git a/README.md b/README.md index 2408ce0..d08d8b6 100644 --- a/README.md +++ b/README.md @@ -45,7 +45,14 @@ Solid lines = our replication, dashed lines = paper reference curves: Alibaba Cluster H (1,200 nodes, 5,592 GPUs, mixed node sizes 1/2/4/8 GPUs). Inflation-based evaluation with 6 placement strategies. -![FGD Standalone](experiments/fgd-standalone/figures/full_run/comparison_all.png) +| Figure | Ours | Paper | +|:--:|:--:|:--:| +| Fig. 7 | ![Figure 7 Ours](standalone_fgd_replication/result/fig7-runs10-seed42/figure7.png) | ![Figure 7 Paper](standalone_fgd_replication/result/fig7-runs10-seed42/paper-figure7.png) | +| Fig. 9 | ![Figure 9 Ours](standalone_fgd_replication/result/fig9-runs10-seed42/figure9.png) | ![Figure 9 Paper](standalone_fgd_replication/result/fig9-runs10-seed42/paper-figure9.png) | +| Fig. 11 | ![Figure 11 Ours](standalone_fgd_replication/result/fig11-runs10-seed42/figure11.png) | ![Figure 11 Paper](standalone_fgd_replication/result/fig11-runs10-seed42/paper-figure11.png) | +| Fig. 12 | ![Figure 12 Ours](standalone_fgd_replication/result/fig12-runs10-seed42/figure12.png) | ![Figure 12 Paper](standalone_fgd_replication/result/fig12-runs10-seed42/paper-figure12.png) | +| Fig. 13 | ![Figure 13 Ours](standalone_fgd_replication/result/fig13-runs10-seed42/figure13.png) | ![Figure 13 Paper](standalone_fgd_replication/result/fig13-runs10-seed42/paper-figure13.png) | +| Fig. 14 | ![Figure 14 Ours](standalone_fgd_replication/result/fig14-runs10-seed42/figure14.png) | ![Figure 14 Paper](standalone_fgd_replication/result/fig14-runs10-seed42/paper-figure14.png) | ### FGD via Gavel -- Alibaba Split Cluster diff --git a/docs/fgd-replication-plan.pdf b/docs/fgd-replication-plan.pdf new file mode 100644 index 0000000..ffc5c6a Binary files /dev/null and b/docs/fgd-replication-plan.pdf differ diff --git a/standalone_fgd_replication/README.md b/standalone_fgd_replication/README.md new file mode 100644 index 0000000..f18fc27 --- /dev/null +++ b/standalone_fgd_replication/README.md @@ -0,0 +1,307 @@ +# FGD Replication — Experiment Scripts + +Replication of *"Beware of Fragmentation: Scheduling GPU-Sharing Workloads with +Fragmentation Gradient Descent"* (USENIX ATC '23). + +All scripts are run from `fgd_replication/` and read trace data from +`../alibaba_traces/cluster-trace-gpu-v2023/`. + +--- + +## Result Directory Mapping + +Every script writes results into `result//` where `` encodes the +script, figure, and key parameters. The table below shows the mapping from +command to result directory and the files produced inside it. + +| Command | Result directory | Files | +|---|---|---| +| `python3 exp_fig7.py --num-runs 10 --seed 42` | `result/fig7-runs10-seed42/` | `figure7_results.csv`, `figure7.png`, `experiment_summary.log` | +| `python3 exp_fig9.py --num-runs 10 --seed 42` | `result/fig9-runs10-seed42/` | `figure9a_unalloc.csv`, `figure9b_occupied.csv`, `figure9c_failed.csv`, `figure9d_breakdown.csv`, `figure9.png`, `experiment_summary.log` | +| `python3 exp_fig11_14.py --figures 11 --num-runs 10 --seed 42` | `result/fig11-runs10-seed42/` | `figure11_results.csv`, `figure11.png`, `experiment_summary.log` | +| `python3 exp_fig11_14.py --figures 12 --num-runs 10 --seed 42` | `result/fig12-runs10-seed42/` | `figure12_results.csv`, `figure12.png`, `experiment_summary.log` | +| `python3 exp_fig11_14.py --figures 13 --num-runs 10 --seed 42` | `result/fig13-runs10-seed42/` | `figure13_results.csv`, `figure13.png`, `experiment_summary.log` | +| `python3 exp_fig11_14.py --figures 14 --num-runs 10 --seed 42` | `result/fig14-runs10-seed42/` | `figure14_results.csv`, `figure14.png`, `experiment_summary.log` | +| `python3 exp_dist_shift.py --task-order ascending --schedulers Random,BestFit,DotProd,Packing,Clustering,FGD-Full,FGD-2000,W-FGD-2000,U-FGD` | `result/dist-shift-ascending-100/` | `experiment_summary.log` | +| `python3 exp_dist_shift.py --task-order descending --schedulers Random,BestFit,DotProd,Packing,Clustering,FGD-Full,FGD-2000,W-FGD-2000,U-FGD` | `result/dist-shift-descending-100/` | `experiment_summary.log` | +| `python3 exp_dist_shift.py --task-order phased --tier-order 0,1,2,3,4 --schedulers Random,BestFit,DotProd,Packing,Clustering,FGD-Full,FGD-2000,W-FGD-2000,U-FGD` | `result/dist-shift-phased-01234-100/` | `experiment_summary.log` | +| `python3 exp_dist_shift.py --task-order phased --tier-order 1,2,0,3,4 --schedulers Random,BestFit,DotProd,Packing,Clustering,FGD-Full,FGD-2000,W-FGD-2000,U-FGD` | `result/dist-shift-phased-12034-100/` | `experiment_summary.log` | + +**Key naming rules:** +- `fig7` and `fig9` are fixed prefixes for their scripts. +- `fig11_14` uses `fig{N}` for a single figure or `fig{A}-{B}-...` when + multiple figures are run together in one invocation. +- Changing `--num-runs` or `--seed` produces a separate directory, so results + from different runs never overwrite each other. +- `dist-shift` uses `dist-shift-{order}-{scale}` where `order` is the + `--task-order` value (`trace`, `ascending`, `descending`, or + `phased-{digits}` encoding the tier sequence) and `scale` is the + `--cluster-scale` value. For example, `--task-order phased --tier-order + 3,2,1,4,0 --cluster-scale 50` produces `dist-shift-phased-32140-50/`. + +**Plot-only mode** (`--plot-csv`) reads from an existing directory and writes +the updated PNG back into the same directory. It does not create a new directory. + +--- + +## Scripts + +### `exp_fig7.py` — Figure 7(a)/(b): Fragmentation vs arrived workload + +Runs Monte-Carlo workload inflation using the default trace +(`openb_pod_list_default.csv`) and plots: +- **Figure 7(a):** fragmentation rate (%) vs arrived GPU workload (%) +- **Figure 7(b):** fragmented GPUs / total resources (%) vs arrived GPU workload (%) + +**Arguments** + +| Argument | Default | Description | +|---|---|---| +| `--num-runs` | 3 | Runs per scheduler (paper uses 10) | +| `--seed` | 42 | Base random seed | +| `--max-workload` | 120.0 | Stop when arrived workload reaches this % of GPU capacity | +| `--sample-interval` | 5.0 | Record fragmentation every this many % of arrived workload | +| `--fgd-popularity-threshold` | 95.0 | Typical-pod popularity threshold (%) used for FGD scoring | +| `--schedulers` | `all` | Comma-separated subset to run, e.g. `FGD,Packing` | +| `--plot-csv` | — | Path to existing result CSV; skips experiment and plots only | + +**Result directory:** `result/fig7-runs{N}-seed{S}/` + +**Output files:** +- `figure7_results.csv` — columns: `scheduler, arrived_workload_pct, frag_rate, frag_total_pct, run` +- `figure7.png` +- `experiment_summary.log` + +**Examples** +```bash +# Full run (paper settings) +python3 exp_fig7.py --num-runs 10 --seed 42 + +# Quick test +python3 exp_fig7.py --num-runs 1 + +# Run only FGD and Packing +python3 exp_fig7.py --schedulers FGD,Packing + +# Plot from saved CSV +python3 exp_fig7.py --plot-csv result/fig7-runs10-seed42/figure7_results.csv +``` + +--- + +### `exp_fig9.py` — Figure 9: Multi-metric evaluation (4 sub-figures) + +Monte-Carlo workload inflation producing four sub-figures: +- **(a)** Unallocated GPU % vs arrived workload (80–120% range) +- **(b)** Occupied nodes vs arrived workload (0–100% range) +- **(c)** Failed task GPU demand by category at 96% arrival (bar chart) +- **(d)** Fragmentation breakdown by cause at end of run (bar chart) + +**Arguments** + +| Argument | Default | Description | +|---|---|---| +| `--num-runs` | 10 | Monte-Carlo runs per scheduler | +| `--seed` | 42 | Base random seed | +| `--sample-interval` | 2.0 | Record metrics every this many % of arrived workload | +| `--max-arrival` | 120.0 | Stop when arrived workload reaches this % of GPU capacity | +| `--fgd-popularity-threshold` | 95.0 | Typical-pod popularity threshold (%) used for FGD scoring | +| `--schedulers` | `all` | Comma-separated subset to run, e.g. `FGD,Packing` | +| `--plot-csv` | — | Path to result directory containing all 4 CSVs; plots only | + +**Result directory:** `result/fig9-runs{N}-seed{S}/` + +**Output files:** +- `figure9a_unalloc.csv` — columns: `scheduler, arrived_pct, unalloc_gpu_pct, run` +- `figure9b_occupied.csv` — columns: `scheduler, arrived_pct, occupied_nodes, run` +- `figure9c_failed.csv` — columns: `scheduler, gpu_category, sum_gpu_demand, run` +- `figure9d_breakdown.csv` — columns: `scheduler, cause, pct, run` +- `figure9.png` +- `experiment_summary.log` + +**Examples** +```bash +# Full run +python3 exp_fig9.py --num-runs 10 --seed 42 + +# Quick test +python3 exp_fig9.py --num-runs 1 + +# Run only FGD and Packing +python3 exp_fig9.py --schedulers FGD,Packing + +# Plot from saved CSVs +python3 exp_fig9.py --plot-csv result/fig9-runs10-seed42/ +``` + +--- + +### `exp_fig11_14.py` — Figures 11–14: Sensitivity analysis + +Evaluates schedulers as workload composition varies. Each figure loads a +different set of pre-built trace files; no synthetic sampling is performed. + +**Arguments** + +| Argument | Default | Description | +|---|---|---| +| `--figures` | `11,12,13,14` | Comma-separated list of figures to run | +| `--num-runs` | 10 | Monte-Carlo runs per (proportion, scheduler) combination | +| `--seed` | 42 | Base random seed | +| `--fgd-popularity-threshold` | 95.0 | Typical-pod popularity threshold (%) used for FGD scoring | +| `--schedulers` | `all` | Comma-separated subset to run, e.g. `FGD,Packing` | +| `--plot-csv` | — | One or more CSV paths; plots only. Accepts multiple files | + +**Result directory:** `result/fig{X}-runs{N}-seed{S}/` +(e.g., `fig11-12-runs10-seed42` when running figures 11 and 12 together) + +**Output files** (one per figure): +- `figure{N}_results.csv` — columns: `proportion, scheduler, unalloc_gpu_pct, std` +- `figure{N}.png` +- `experiment_summary.log` + +**Trace files used** + +| Figure | x-axis | Trace files | +|---|---|---| +| 11 | GPU-sharing % of GPU requests | `openb_pod_list_gpushare{40,60,80,100}.csv` | +| 12 | Multi-GPU % of GPU requests | `openb_pod_list_multigpu{20,30,40,50}.csv` | +| 13 | GPU-type-constrained % of GPU requests | `openb_pod_list_gpuspec{10,20,25,33}.csv` | +| 14 | Non-GPU % of task count | `openb_pod_list_cpu{050,100,200,250}.csv` | + +**Examples** +```bash +# Run all four figures +python3 exp_fig11_14.py + +# Run single figure +python3 exp_fig11_14.py --figures 11 + +# Run subset of figures +python3 exp_fig11_14.py --figures 11,12 --num-runs 10 + +# Run only FGD and Packing across all figures +python3 exp_fig11_14.py --schedulers FGD,Packing + +# Plot from saved CSVs +python3 exp_fig11_14.py --plot-csv result/fig11-runs10-seed42/figure11_results.csv +python3 exp_fig11_14.py --plot-csv result/fig11-runs10-seed42/figure11_results.csv \ + result/fig12-runs10-seed42/figure12_results.csv +``` + +--- + +### `exp_dist_shift.py` — Distribution-shift experiment + +Replays the full default trace (`openb_pod_list_default.csv`) through the real +cluster in a single pass and measures final fragmentation, GPU allocation, and +throughput for each scheduler. Unlike `exp_fig7.py`, there is no random +sampling — the trace is played exactly once in the chosen order. + +The key question is how well each FGD variant handles a mismatch between the +distribution it was initialised with (e.g. the first N tasks, or a uniform +grid) and the actual workload that arrives. + +**Scheduler variants** + +| Name | Description | +|---|---| +| `Random`, `BestFit`, `DotProd`, `Packing`, `Clustering` | Baseline schedulers | +| `FGD-Full` | FGD with oracle knowledge of the full trace distribution | +| `FGD-N` | FGD with static distribution from the first N tasks (e.g. `FGD-500`) | +| `W-FGD-M` | Windowed FGD with sliding window of size M (e.g. `W-FGD-200`) | +| `B-FGD` | Bayesian FGD; starts with a uniform prior and updates online | +| `U-FGD` | FGD with a uniform prior over the CPU × GPU grid | + +For `FGD-N` and `W-FGD-M`, N and M are parsed directly from the scheduler name. + +**Arguments** + +| Argument | Default | Description | +|---|---|---| +| `--task-order` | `trace` | Task arrival order: `trace` (original creation-time order), `ascending`/`descending` (sorted by GPU demand), `phased` (GPU demand tiers in sequence) | +| `--cluster-scale` | `100.0` | Cluster size as % of original (e.g. `50` keeps 50% of each node type) | +| `--tier-order` | `0,1,2,3,4` | Tier sequence for `phased` mode. Tiers: 0=CPU-only, 1=small fractional (<0.5), 2=large fractional (0.5–1), 3=single full GPU, 4=multi-GPU | +| `--schedulers` | `all` | Comma-separated scheduler names to run | +| `--prior-strength` | `10.0` | B-FGD pseudo-count total (only used when B-FGD is selected) | +| `--min-gpu-tasks` | `50` | B-FGD falls back to Packing until this many GPU tasks are observed (only used when B-FGD is selected) | + +**Result directory:** `result/dist-shift-{order}-{scale}/` +(e.g. `dist-shift-trace-100`, `dist-shift-phased-32140-50`) + +**Output files:** +- `experiment_summary.log` — final Frag%, Alloc%, Scheduled, Failed, Time(s) per scheduler + +**Examples** +```bash +# Default: trace order, full cluster, all schedulers +python3 exp_dist_shift.py + +# Phased arrival (full-GPU tasks first, then fractional, then CPU-only) +python3 exp_dist_shift.py --task-order phased --tier-order 3,2,1,4,0 + +# Ascending GPU demand order, half-size cluster +python3 exp_dist_shift.py --task-order ascending --cluster-scale 50 + +# Compare FGD variants only +python3 exp_dist_shift.py --schedulers FGD-Full,FGD-500,W-FGD-200,B-FGD,U-FGD + +# FGD with first-1000-task distribution vs windowed FGD with window 300 +python3 exp_dist_shift.py --schedulers FGD-1000,W-FGD-300 +``` + +--- + +## Configuration Assumptions + +### Task type representation (all experiments) + +FGD needs a discrete task-type distribution to compute fragmentation gradients. +Continuous CPU/GPU demands are bucketed as follows: + +| Resource | Bucketing rule | Rationale | +|---|---|---| +| CPU | Round to nearest multiple of 4 cores | Reduces ~hundreds of unique values to ~20 types | +| GPU (fractional, < 1) | Round to 2 decimal places | Preserves GPU-sharing granularity | +| GPU (integer, ≥ 1) | Use exact integer | Multi-GPU tasks are already discrete | + +This bucketing is applied in `trace_loader._bucket_cpu()` and consistently +throughout all scripts. + +### Per-figure assumptions + +**Figure 7(a)/(b) — `exp_fig7.py`** +- Trace: `openb_pod_list_default.csv` (8,152 tasks, 13.3% non-GPU) +- FGD distribution: computed from the full default trace (oracle knowledge) +- Fragmentation snapshot: every 5% of arrived workload +- Outputs both 7(a) and 7(b) from the same run and CSV + +**Figure 9 — `exp_fig9.py`** +- Trace: `openb_pod_list_default.csv` +- FGD distribution: computed from the full default trace (oracle knowledge) +- Snapshot for 9(c) failed-task breakdown: taken at exactly 96% arrival +- Snapshot interval for 9(a)/(b) curves: every 2% of arrived workload +- Occupied node criterion: `allocated_cpu > 0` OR any GPU slot `< 1.0` +- Fragmentation breakdown (9d): computed at end of run using per-node, + per-task-type fragmentation decomposed into *deficient*, *stranded*, *non-GPU* + +**Figures 11–14 — `exp_fig11_14.py`** +- Each (figure, proportion) pair loads its own dedicated trace file; no + synthetic reweighting is applied +- FGD distribution: computed from whichever trace file is loaded for that + proportion — FGD has oracle knowledge of the current workload mix +- Figure 13 uses `GpuTypeAwareCluster`: tasks with a non-empty `gpu_spec` + field can only be placed on nodes whose `gpu_model` matches +- Figure 12 trace files (`multigpu*.csv`) have a shorter column format + (no `gpu_spec`, `qos`, or timestamp columns); the loader handles this + gracefully with optional field access + +**Distribution-shift — `exp_dist_shift.py`** +- Trace: `openb_pod_list_default.csv` (same as Fig 7a/9) +- Single deterministic pass; no Monte-Carlo sampling +- `FGD-Full` uses oracle knowledge of the full trace distribution +- `FGD-N` fixes the distribution to the first N tasks and never updates +- `W-FGD-M` pre-populates its window with the first M tasks, then slides online +- `B-FGD` starts from a uniform prior (derived from cluster node specs) and updates after every observed task +- `U-FGD` uses a static uniform distribution over the CPU × GPU grid +- Phased mode groups tasks into five GPU-demand tiers and replays them in the specified tier sequence diff --git a/standalone_fgd_replication/exp_dist_shift.py b/standalone_fgd_replication/exp_dist_shift.py new file mode 100644 index 0000000..9570183 --- /dev/null +++ b/standalone_fgd_replication/exp_dist_shift.py @@ -0,0 +1,1379 @@ +""" +Distribution-Shift Experiment Runner for FGD Replication + +Processes tasks in trace order and measures fragmentation under distribution shift. +""" + +import os +from typing import List, Dict, Tuple +from dataclasses import dataclass, field +from collections import Counter, defaultdict + +from simulator import Task, Node, Cluster, TaskDistribution +from schedulers import ( + Scheduler, get_all_schedulers, get_scheduler, + ClusteringScheduler, FGDScheduler, WindowedFGDScheduler, + BayesianFGDScheduler +) +from trace_loader import AlibabaTraceLoader + + +def build_scheduler(name: str, experiment, + prior_strength: float = 10.0, + min_gpu_tasks: int = 50) -> 'Scheduler': + """Create a scheduler instance by name, parsing N/M from FGD-N / W-FGD-M. + + Supported names: + Random, BestFit, DotProd, Packing, Clustering — baseline schedulers + FGD-Full — FGD with full trace distribution + FGD-N — FGD with first-N-task distribution (N any positive int) + W-FGD-M — Windowed FGD with sliding window size M + B-FGD — Bayesian FGD + U-FGD — FGD with uniform grid distribution + + Returns None if the name is not recognised. + """ + import re + + # FGD-N: static first-N distribution (N encoded in the name) + m = re.fullmatch(r'FGD-(\d+)', name) + if m: + n = int(m.group(1)) + dist = experiment._compute_initial_distribution(n) + sched = FGDScheduler(scheduling_task_types=dist.get_task_types()) + sched.name = name + return sched + + # W-FGD-M: sliding window with size M encoded in the name + m = re.fullmatch(r'W-FGD-(\d+)', name) + if m: + window_size = int(m.group(1)) + return WindowedFGDScheduler(window_size=window_size) + + # Fixed-name variants + if name == 'FGD-Full': + sched = FGDScheduler() + sched.name = 'FGD-Full' + return sched + + if name == 'U-FGD': + uniform_types = build_uniform_task_types(experiment.loader.nodes) + sched = FGDScheduler(scheduling_task_types=uniform_types) + sched.name = 'U-FGD' + return sched + + if name == 'B-FGD': + return BayesianFGDScheduler(prior_strength=prior_strength, + min_gpu_tasks=min_gpu_tasks) + + # Baseline schedulers (non-FGD) + baselines = {s.name: s for s in get_all_schedulers() + if not isinstance(s, FGDScheduler)} + if name in baselines: + return baselines[name] + + return None + + +def build_uniform_task_types(nodes) -> List[Tuple[Tuple[float, float], float]]: + """Build uniform distribution over (cpu, gpu) grid from cluster node specs.""" + max_cpu = int(max(n.total_cpu for n in nodes)) + max_gpu = int(max(n.num_gpus for n in nodes)) + cpu_values = list(range(0, max_cpu + 1, 4)) + gpu_values = [round(i * 0.1, 1) for i in range(11)] # 0.0..1.0 + gpu_values += list(range(2, max_gpu + 1)) # 2, 3, ..., max_gpu + n_types = len(cpu_values) * len(gpu_values) + weight = 1.0 / n_types + task_types = [((cpu, gpu), weight) for cpu in cpu_values for gpu in gpu_values] + print(f" U-FGD uniform grid: {len(cpu_values)} CPU x {len(gpu_values)} GPU = {n_types} types") + return task_types + + +@dataclass +class ExperimentResult: + """Results from a single experiment run""" + scheduler_name: str + # Figure 7(a): (arrived_pct, frag_rate) + fragmentation_curve: List[Tuple[float, float]] = field(default_factory=list) + # Figure 7(b): (arrived_pct, fragmented_gpu_over_total_gpu_pct) + frag_total_curve: List[Tuple[float, float]] = field(default_factory=list) + # Figure 9(a): (arrived_pct, unallocated_gpu_pct) + unalloc_curve: List[Tuple[float, float]] = field(default_factory=list) + # Figure 9(b): (arrived_pct, occupied_nodes) + occupied_curve: List[Tuple[float, float]] = field(default_factory=list) + # Figure 9(c): failed tasks at snapshot by GPU category + failed_by_category: Dict[str, float] = field(default_factory=dict) + # Figure 9(d): fragmentation breakdown by cause at end + frag_breakdown: Dict[str, float] = field(default_factory=dict) + final_frag_rate: float = 0.0 + final_frag_total_pct: float = 0.0 + final_gpu_alloc_rate: float = 0.0 + tasks_scheduled: int = 0 + tasks_failed: int = 0 + elapsed_sec: float = 0.0 + + +class DistShiftExperiment: + """ + Distribution-Shift Experiment: processes tasks in creation_time order from the trace + and measures fragmentation under various scheduling policies. + """ + + def __init__( + self, + data_dir: str, + window_size: int = 500, + task_order: str = 'trace', + cluster_scale: float = 100.0, + tier_order: List[int] = None, + fgd_popularity_threshold: float = 95 + ): + self.data_dir = data_dir + self.window_size = window_size + self.task_order = task_order + self.cluster_scale = cluster_scale + self.fgd_popularity_threshold = fgd_popularity_threshold + self.loader = AlibabaTraceLoader(data_dir) + + # Load trace data + self.loader.load_nodes() + self.loader.load_tasks() + + # Reduce cluster size if requested + self.original_node_count = len(self.loader.nodes) + if cluster_scale < 100.0: + self.loader.nodes = self._scale_cluster(self.loader.nodes, cluster_scale) + self.scaled_node_count = len(self.loader.nodes) + + # Sort tasks by type if requested (creates skewed arrival pattern) + if task_order in ('ascending', 'descending'): + reverse = (task_order == 'descending') + self.loader.tasks.sort( + key=lambda t: (round(t.gpu_demand, 2), round(t.cpu_demand / 4) * 4), + reverse=reverse + ) + elif task_order == 'phased': + self.loader.tasks, self.phase_info = self._phased_order(self.loader.tasks, tier_order or [0,1,2,3,4]) + + # Compute TWO task distributions: + # 1. Full distribution (all tasks) - for original FGD baseline + # 2. First-N distribution - for penalized FGD and W-FGD starting point + self.full_task_distribution = self.loader.compute_task_distribution() + self.fgd_scoring_distribution = self.loader.compute_task_distribution( + popularity_threshold=self.fgd_popularity_threshold + ) + self.first_n_distribution = self._compute_initial_distribution(window_size) + + # Get cluster capacity + self.total_gpu_capacity = sum(n.num_gpus for n in self.loader.nodes) + + print(f"Loaded trace: {len(self.loader.nodes)} nodes, {self.total_gpu_capacity} GPUs") + print(f"Tasks in trace: {len(self.loader.tasks)}") + print(f"Task order: {task_order}") + print(f"Full distribution: {len(self.full_task_distribution.get_task_types())} task types") + print( + f"FGD scoring distribution (top {self.fgd_popularity_threshold:.0f}%): " + f"{len(self.fgd_scoring_distribution.get_task_types())} task types" + ) + + @staticmethod + def _gpu_category(gpu_demand: float) -> str: + """Categorize GPU demand for Figure 9(c).""" + if gpu_demand < 1: + return "<1" + if gpu_demand == 1: + return "1" + if gpu_demand == 2: + return "2" + return "8" + + @staticmethod + def _count_occupied_nodes(cluster: Cluster) -> int: + """Count nodes with any allocated resource.""" + count = 0 + for node in cluster.nodes: + if node.allocated_cpu > 0 or any(g < 1.0 for g in node.gpu_remaining): + count += 1 + return count + + @staticmethod + def _compute_frag_breakdown(cluster: Cluster) -> Dict[str, float]: + """ + Decompose fragmentation into 3 causes for Figure 9(d): + deficient, stranded, non_gpu. + """ + if cluster.task_distribution is None: + return {"deficient": 0, "stranded": 0, "non_gpu": 0} + + task_types = cluster.task_distribution.get_task_types() + deficient = 0.0 + stranded = 0.0 + non_gpu = 0.0 + + for node in cluster.nodes: + if node.total_unallocated_gpu == 0: + continue + + for (cpu_demand, gpu_demand), popularity in task_types: + task = Task(task_id=-1, cpu_demand=cpu_demand, gpu_demand=gpu_demand) + frag = node.get_fragmentation_for_task(task) + if frag == 0: + continue + + weighted_frag = popularity * frag + + if gpu_demand == 0: + non_gpu += weighted_frag + elif gpu_demand > node.scalar_gpu_capacity: + deficient += weighted_frag + elif cpu_demand > node.remaining_cpu: + stranded += weighted_frag + else: + deficient += weighted_frag + + total = deficient + stranded + non_gpu + if total == 0: + return {"deficient": 0, "stranded": 0, "non_gpu": 0} + + return { + "deficient": deficient / total * 100, + "stranded": stranded / total * 100, + "non_gpu": non_gpu / total * 100, + } + + def _compute_initial_distribution(self, n: int) -> TaskDistribution: + """ + Compute task distribution from first N tasks of the trace. + + Applies the same typical-pod popularity filtering (top K%) as FGD-Full, + but on the first-N subset, then renormalizes. + """ + subset = self.loader.tasks[:n] + dist = TaskDistribution() + type_counts: Counter = Counter() + for task in subset: + gpu_rounded = round(task.gpu_demand, 2) + cpu_bucket = round(task.cpu_demand / 4) * 4 + type_counts[(cpu_bucket, gpu_rounded)] += 1 + + total = sum(type_counts.values()) + if total == 0: + return dist + + # Keep only top types whose cumulative count reaches threshold%. + threshold = self.fgd_popularity_threshold + expected = threshold * total / 100.0 + sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True) + + selected: Dict[Tuple[float, float], int] = {} + cum = 0 + for type_key, count in sorted_types: + selected[type_key] = count + cum += count + if cum >= expected: + break + + for (cpu, gpu), count in selected.items(): + dist.add_task_type(cpu, gpu, count / cum) + return dist + + @staticmethod + def _phased_order(tasks: list, tier_order: List[int]) -> list: + """ + Phased arrival order: tasks grouped by GPU demand tier, tiers ordered by tier_order. + Within each tier, tasks are shuffled (seeded). + + Tiers: + 0: gpu == 0 (CPU-only / no-GPU tasks) + 1: 0 < gpu < 0.5 (small fractional GPU) + 2: 0.5 <= gpu < 1 (large fractional GPU) + 3: gpu == 1 (single full GPU) + 4: gpu > 1 (multi-GPU) + """ + import random as rng + + tiers = {0: [], 1: [], 2: [], 3: [], 4: []} + for task in tasks: + g = task.gpu_demand + if g == 0: + tier = 0 + elif g < 0.5: + tier = 1 + elif g < 1.0: + tier = 2 + elif g == 1.0: + tier = 3 + else: + tier = 4 + tiers[tier].append(task) + + # Shuffle within each tier (seeded for reproducibility) + r = rng.Random(42) + for tier_tasks in tiers.values(): + r.shuffle(tier_tasks) + + lines = [f"Tier order: {tier_order}"] + result = [] + for phase_idx, tier_id in enumerate(tier_order): + tier_tasks = tiers[tier_id] + if tier_tasks: + lines.append(f" Phase {phase_idx}: Tier {tier_id} - {len(tier_tasks)} tasks " + f"(gpu range: {min(t.gpu_demand for t in tier_tasks):.2f}" + f"-{max(t.gpu_demand for t in tier_tasks):.2f})") + result.extend(tier_tasks) + + phase_info = "\n".join(lines) + print(phase_info) + return result, phase_info + + def format_distribution_comparison(self) -> str: + """Format side-by-side comparison of full vs first-N distributions""" + n = self.window_size + full_types = {(cpu, gpu): pop for (cpu, gpu), pop in self.full_task_distribution.get_task_types()} + first_n_types = {(cpu, gpu): pop for (cpu, gpu), pop in self.first_n_distribution.get_task_types()} + + all_keys = sorted(set(full_types) | set(first_n_types), key=lambda k: (-full_types.get(k, 0))) + + lines = [] + lines.append(f"{'Task Type (cpu,gpu)':<22} {'Full%':>8} {'First-'+str(n)+'%':>10} {'Diff':>8}") + lines.append("-" * 52) + for cpu, gpu in all_keys: + f = full_types.get((cpu, gpu), 0) * 100 + p = first_n_types.get((cpu, gpu), 0) * 100 + diff = p - f + marker = " *" if abs(diff) > 3 else "" + lines.append(f" ({cpu:>4}, {gpu:>5}) {f:>7.1f} {p:>9.1f} {diff:>+7.1f}{marker}") + lines.append(f" {'Types present:':<20} {len(full_types):>7} {len(first_n_types):>9}") + return "\n".join(lines) + + @staticmethod + def _scale_cluster(nodes: list, scale_pct: float) -> list: + """Keep scale_pct% of nodes per type (same cpu, mem, gpu count, gpu model). At least 1 per type.""" + from collections import defaultdict + import math + + # Group nodes by type + type_groups: dict = defaultdict(list) + for node in nodes: + key = (node.total_cpu, node.memory_mib, node.num_gpus, node.gpu_model) + type_groups[key].append(node) + + scaled_nodes = [] + print(f"\nCluster scaling to {scale_pct}%:") + for key, group in sorted(type_groups.items()): + keep = max(1, math.ceil(len(group) * scale_pct / 100.0)) + scaled_nodes.extend(group[:keep]) + print(f" {key}: {len(group)} -> {keep}") + + print(f" Total: {len(nodes)} -> {len(scaled_nodes)} nodes") + return scaled_nodes + + def create_fresh_cluster(self) -> Cluster: + """Create a fresh cluster with full distribution (always used for evaluation)""" + cluster = Cluster() + for i, orig_node in enumerate(self.loader.nodes): + node = Node( + node_id=i, + total_cpu=orig_node.total_cpu, + num_gpus=orig_node.num_gpus, + name=orig_node.name, + gpu_model=orig_node.gpu_model, + memory_mib=orig_node.memory_mib + ) + cluster.add_node(node) + + # Always use full distribution for evaluation (compute_fragmentation_rate) + cluster.set_task_distribution(self.full_task_distribution) + return cluster + + def run_single( + self, + scheduler: Scheduler, + sample_interval_pct: float = 2.0, + max_arrival_pct: float = 120.0, + snapshot_pct: float = 96.0, + show_progress: bool = True + ) -> ExperimentResult: + """ + Run a single trace-replay experiment with one scheduler. + + Tasks are processed in creation_time order until the trace is exhausted. + Cluster always uses full distribution for evaluation. + Schedulers carry their own scheduling distribution if needed. + """ + import time + from tqdm import tqdm + + cluster = self.create_fresh_cluster() + result = ExperimentResult(scheduler_name=scheduler.name) + + tasks = self.loader.tasks # already sorted by creation_time + + # Reset stateful schedulers + if isinstance(scheduler, ClusteringScheduler): + scheduler.reset() + if isinstance(scheduler, WindowedFGDScheduler): + scheduler.reset() + # Pre-populate window with first N tasks + for t in tasks[:scheduler.window_size]: + scheduler.observe_task(t) + if isinstance(scheduler, BayesianFGDScheduler): + scheduler.reset() + # Uniform prior from cluster specs + max_cpu = max(n.total_cpu for n in self.loader.nodes) + max_gpu = max(n.num_gpus for n in self.loader.nodes) + scheduler.set_uniform_prior(max_cpu, max_gpu) + if isinstance(scheduler, FGDScheduler) and not isinstance( + scheduler, (WindowedFGDScheduler, BayesianFGDScheduler) + ): + # Apply typical-pod scoring only to plain FGD variants that did not + # come with an explicit scheduling distribution. + # This preserves intended behavior for FGD-N / U-FGD. + if scheduler.scheduling_task_types is None: + scheduler.scheduling_task_types = self.fgd_scoring_distribution.get_task_types() + + pbar = tqdm( + total=len(tasks), + desc=f"{scheduler.name:16}", + unit="task", + disable=not show_progress, + ncols=90 + ) + + t_start = time.monotonic() + cumulative_gpu_demand = 0.0 + max_gpu_demand = self.total_gpu_capacity * max_arrival_pct / 100.0 + next_sample_pct = sample_interval_pct + snapshot_taken = False + failed_tasks_until_snapshot: List[Task] = [] + + # Figure 7 should start from the true initial cluster state (x=0), + # not from a synthetic point copied from the first sampled value. + initial_frag_rate = cluster.compute_fragmentation_rate() + initial_frag_total_pct = ( + cluster.compute_cluster_fragmentation() / self.total_gpu_capacity + ) * 100.0 + result.fragmentation_curve.append((0.0, initial_frag_rate)) + result.frag_total_curve.append((0.0, initial_frag_total_pct)) + + for task in tasks: + cumulative_gpu_demand += task.gpu_demand + arrived_pct = (cumulative_gpu_demand / self.total_gpu_capacity) * 100 + + # Feed task to adaptive schedulers before scheduling + if isinstance(scheduler, WindowedFGDScheduler): + scheduler.observe_task(task) + if isinstance(scheduler, BayesianFGDScheduler): + scheduler.observe_task(task) + + # Try to schedule + if scheduler.schedule(task, cluster): + result.tasks_scheduled += 1 + else: + result.tasks_failed += 1 + if not snapshot_taken: + failed_tasks_until_snapshot.append(task) + + # 9(c) snapshot at specified arrived percentage. + if not snapshot_taken and arrived_pct >= snapshot_pct: + snapshot_taken = True + cat_sums: Dict[str, float] = defaultdict(float) + for failed_task in failed_tasks_until_snapshot: + cat = self._gpu_category(failed_task.gpu_demand) + cat_sums[cat] += failed_task.gpu_demand + result.failed_by_category = dict(cat_sums) + + # 9(a)/(b) sampled curves. + while arrived_pct >= next_sample_pct and next_sample_pct <= max_arrival_pct: + frag_rate = cluster.compute_fragmentation_rate() + frag_total_pct = ( + cluster.compute_cluster_fragmentation() / self.total_gpu_capacity + ) * 100.0 + result.fragmentation_curve.append((next_sample_pct, frag_rate)) + result.frag_total_curve.append((next_sample_pct, frag_total_pct)) + + unalloc_pct = (cluster.total_unallocated_gpu / self.total_gpu_capacity) * 100 + occupied = self._count_occupied_nodes(cluster) + result.unalloc_curve.append((next_sample_pct, unalloc_pct)) + result.occupied_curve.append((next_sample_pct, occupied)) + next_sample_pct += sample_interval_pct + + pbar.update(1) + + if cumulative_gpu_demand >= max_gpu_demand: + break + + pbar.close() + + if not snapshot_taken: + cat_sums: Dict[str, float] = defaultdict(float) + for failed_task in failed_tasks_until_snapshot: + cat = self._gpu_category(failed_task.gpu_demand) + cat_sums[cat] += failed_task.gpu_demand + result.failed_by_category = dict(cat_sums) + + result.frag_breakdown = self._compute_frag_breakdown(cluster) + + # Record final metrics + result.elapsed_sec = time.monotonic() - t_start + result.final_frag_rate = cluster.compute_fragmentation_rate() + result.final_frag_total_pct = ( + cluster.compute_cluster_fragmentation() / self.total_gpu_capacity + ) * 100.0 + result.final_gpu_alloc_rate = cluster.gpu_allocation_rate + + return result + + def run_experiment( + self, + schedulers: List[Scheduler] = None, + sample_interval_pct: float = 2.0, + max_arrival_pct: float = 120.0, + snapshot_pct: float = 96.0, + show_progress: bool = True + ) -> Dict[str, List[ExperimentResult]]: + """ + Run trace-replay experiment for multiple schedulers. + Single run per scheduler (deterministic — no random sampling). + """ + if schedulers is None: + schedulers = get_all_schedulers() + + results: Dict[str, List[ExperimentResult]] = {s.name: [] for s in schedulers} + + for scheduler in schedulers: + result = self.run_single( + scheduler, + sample_interval_pct=sample_interval_pct, + max_arrival_pct=max_arrival_pct, + snapshot_pct=snapshot_pct, + show_progress=show_progress + ) + results[scheduler.name].append(result) + + avg_frag = sum(r.final_frag_rate for r in results[scheduler.name]) / len(results[scheduler.name]) + avg_alloc = sum(r.final_gpu_alloc_rate for r in results[scheduler.name]) / len(results[scheduler.name]) + avg_sched = sum(r.tasks_scheduled for r in results[scheduler.name]) / len(results[scheduler.name]) + avg_failed = sum(r.tasks_failed for r in results[scheduler.name]) / len(results[scheduler.name]) + print( + f" {scheduler.name:16}: Frag={avg_frag:.1f}%, " + f"Alloc={avg_alloc:.1f}%, Scheduled={avg_sched:.0f}, Failed={avg_failed:.0f}" + ) + + return results + + + +def format_summary(results: Dict[str, List[ExperimentResult]]) -> str: + """Format summary statistics as a string""" + lines = [] + lines.append("=" * 76) + lines.append("EXPERIMENT SUMMARY") + lines.append("=" * 76) + lines.append(f"\n{'Scheduler':<16} {'Avg Frag%':>10} {'Avg Alloc%':>12} {'Scheduled':>12} {'Failed':>10} {'Time(s)':>10}") + lines.append("-" * 76) + + for name, result_list in results.items(): + avg_frag = sum(r.final_frag_rate for r in result_list) / len(result_list) + avg_alloc = sum(r.final_gpu_alloc_rate for r in result_list) / len(result_list) + total_scheduled = sum(r.tasks_scheduled for r in result_list) / len(result_list) + total_failed = sum(r.tasks_failed for r in result_list) / len(result_list) + avg_elapsed = sum(r.elapsed_sec for r in result_list) / len(result_list) + + lines.append(f"{name:<16} {avg_frag:>10.1f} {avg_alloc:>12.1f} {total_scheduled:>12.0f} {total_failed:>10.0f} {avg_elapsed:>10.1f}") + + return "\n".join(lines) + + +def print_summary(results: Dict[str, List[ExperimentResult]]): + """Print summary statistics""" + print("\n" + format_summary(results)) + + +def _average_curves(curves: List[List[Tuple[float, float]]]) -> List[Tuple[float, float]]: + """Average multiple curves by x-value.""" + if not curves: + return [] + by_x: Dict[float, List[float]] = defaultdict(list) + for curve in curves: + for x, y in curve: + by_x[x].append(y) + return sorted([(x, sum(ys) / len(ys)) for x, ys in by_x.items()]) + + +def _average_curve_by_key( + result_list: List[ExperimentResult], + curve_key: str, +) -> List[Tuple[float, float]]: + """Average one curve type across runs by x-value.""" + curves = [getattr(r, curve_key) for r in result_list] + return _average_curves(curves) + + +def save_figure7_results_to_csv(results: Dict[str, List[ExperimentResult]], output_dir: str): + """Save Figure 7 artifacts as a single CSV file.""" + import csv + + path = os.path.join(output_dir, 'figure7_results.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow([ + 'scheduler', + 'arrived_workload_pct', + 'frag_rate', + 'frag_total_pct', + 'run', + ]) + + for scheduler_name, result_list in results.items(): + for run_idx, result in enumerate(result_list): + by_x_total = {x: y for x, y in result.frag_total_curve} + for arrived_pct, frag_rate in result.fragmentation_curve: + writer.writerow([ + scheduler_name, + arrived_pct, + frag_rate, + by_x_total.get(arrived_pct, ''), + run_idx, + ]) + + print(f"Figure 7 CSV saved to {path}") + + +def load_figure7_results_from_csv(csv_path: str) -> Dict[str, List[ExperimentResult]]: + """Load Figure 7 CSV into ExperimentResult structures.""" + import csv + + # scheduler -> run -> curves + data = defaultdict(lambda: defaultdict(lambda: { + 'frag_rate': [], + 'frag_total': [], + })) + + with open(csv_path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + scheduler = row['scheduler'] + run = int(row['run']) + x = float(row['arrived_workload_pct']) + y = float(row['frag_rate']) + data[scheduler][run]['frag_rate'].append((x, y)) + + frag_total_raw = row.get('frag_total_pct', '') + if frag_total_raw != '': + data[scheduler][run]['frag_total'].append((x, float(frag_total_raw))) + + results: Dict[str, List[ExperimentResult]] = {} + for scheduler, runs in data.items(): + results[scheduler] = [] + for run_idx in sorted(runs.keys()): + r = ExperimentResult(scheduler_name=scheduler) + r.fragmentation_curve = sorted(runs[run_idx]['frag_rate'], key=lambda p: p[0]) + r.frag_total_curve = sorted(runs[run_idx]['frag_total'], key=lambda p: p[0]) + results[scheduler].append(r) + + return results + + +def plot_figure7(results: Dict[str, List[ExperimentResult]], output_dir: str): + """ + Plot Figure 7 as one image with two sub-panels: + (a) Fragmentation rate + (b) Fragmented GPUs / total resources + """ + try: + import matplotlib + import matplotlib.pyplot as plt + import numpy as np + except ImportError: + print("matplotlib not installed. Skipping Figure 7 plot.") + return + + import re + + matplotlib.rcdefaults() + matplotlib.rcParams['pdf.fonttype'] = 42 + matplotlib.rcParams.update({"font.size": 16}) + matplotlib.rcParams['lines.linewidth'] = 3 + matplotlib.rcParams['savefig.bbox'] = None + matplotlib.rcParams['savefig.pad_inches'] = 0.0 + + fig, axes = plt.subplots(2, 1, figsize=(8.33, 6.00), dpi=100) + + styles = { + 'Random': {'color': 'brown', 'linestyle': '-.'}, + 'DotProd': {'color': 'purple', 'linestyle': '--'}, + 'Clustering': {'color': 'red', 'linestyle': '--'}, + 'Packing': {'color': 'darkgreen', 'linestyle': ':'}, + 'BestFit': {'color': 'orange', 'linestyle': '--'}, + 'BestFit-PN': {'color': '#fdbf6f', 'linestyle': '--'}, + 'FGD': {'color': 'black', 'linestyle': '-'}, + 'FGD-Full': {'color': '#1f77b4', 'linestyle': '-'}, + 'B-FGD': {'color': '#e377c2', 'linestyle': '--'}, + 'U-FGD': {'color': '#17becf', 'linestyle': '-.'}, + } + + variant_colors = [ + '#000000', '#1f77b4', '#17becf', '#e377c2', '#7f7f7f', + '#bcbd22', '#2ca02c', '#9467bd', '#8c564b', '#ff7f0e' + ] + variant_styles = ['-', '--', '-.', ':'] + variant_style_map: Dict[str, Dict[str, str]] = {} + variant_names = sorted([ + n for n in results.keys() + if re.fullmatch(r'FGD-\d+', n) or re.fullmatch(r'W-FGD-\d+', n) + or (n.startswith('FGD') and n not in styles) + ]) + for i, name in enumerate(variant_names): + variant_style_map[name] = { + 'color': variant_colors[i % len(variant_colors)], + 'linestyle': variant_styles[(i // len(variant_colors)) % len(variant_styles)] + } + + def _style_for(name: str) -> Dict[str, str]: + if name in styles: + return styles[name] + if name in variant_style_map: + return variant_style_map[name] + return {'color': 'black', 'linestyle': '-'} + + order = ['Random', 'DotProd', 'Clustering', 'Packing', 'BestFit', 'BestFit-PN', 'FGD', 'FGD-Full', 'B-FGD', 'U-FGD'] + names = [n for n in order if n in results] + names.extend([n for n in results.keys() if n not in names]) + + # 7(a) + ax = axes[0] + for name in names: + avg_curve = _average_curve_by_key(results[name], 'fragmentation_curve') + if not avg_curve: + continue + x_vals = [p[0] for p in avg_curve] + y_vals = [p[1] for p in avg_curve] + style = _style_for(name) + ax.plot(x_vals, y_vals, label=name, color=style['color'], linestyle=style['linestyle']) + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)', fontsize=14) + ax.set_ylabel('Frag Rate (%)', fontsize=14) + ax.set_xlim(0, 120) + ax.set_xticks([0, 20, 40, 60, 80, 100, 120]) + ax.set_ylim(0, 105) + ax.set_yticks([0, 25, 50, 75, 100]) + ax.grid(linestyle='-.', alpha=0.65) + ax.tick_params(axis='both', labelsize=12) + ax.legend(loc='upper left', bbox_to_anchor=(1.02, 1.03), fontsize=12, frameon=False) + + # 7(b) + ax = axes[1] + max_y_7b = 0.0 + for name in names: + avg_curve = _average_curve_by_key(results[name], 'frag_total_curve') + if not avg_curve: + continue + x_vals = [p[0] for p in avg_curve] + y_vals = [p[1] for p in avg_curve] + if y_vals: + max_y_7b = max(max_y_7b, max(y_vals)) + style = _style_for(name) + ax.plot(x_vals, y_vals, label=name, color=style['color'], linestyle=style['linestyle']) + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)', fontsize=14) + ax.set_ylabel('Frag / Total (%)', fontsize=14) + ax.set_xlim(0, 120) + ax.set_xticks([0, 20, 40, 60, 80, 100, 120]) + # Dynamic y-range from actual data, with 5 intervals (6 ticks) from 0 to max. + import math + y_max_7b = max(5.0, max_y_7b * 1.05) + y_max_7b = math.ceil(y_max_7b / 5.0) * 5.0 + ax.set_ylim(0, y_max_7b) + ax.set_yticks(np.linspace(0, y_max_7b, 6)) + ax.grid(linestyle='-.', alpha=0.65) + ax.tick_params(axis='both', labelsize=12) + ax.legend(loc='upper left', bbox_to_anchor=(1.02, 1.03), fontsize=12, frameon=False) + + fig.subplots_adjust(left=0.10, right=0.77, top=0.97, bottom=0.20, hspace=0.72) + captions = [ + "(a) Fragmentation rate grows to 100% as more resources are allocated.", + "(b) Percentage of fragmented GPUs to total resources under our measure.", + ] + p0 = axes[0].get_position() + p1 = axes[1].get_position() + fig.text(0.5, p0.y0 - 0.11, captions[0], ha='center', va='top', fontsize=13, family='serif') + fig.text(0.5, p1.y0 - 0.11, captions[1], ha='center', va='top', fontsize=13, family='serif') + + path = os.path.join(output_dir, 'figure7.png') + plt.savefig(path, dpi=100, bbox_inches=None, pad_inches=0.0) + plt.close(fig) + print(f"Figure 7 plot saved to {path}") + + +def save_figure9_results_to_csv(results: Dict[str, List[ExperimentResult]], output_dir: str): + """Save Figure 9 artifacts as CSV files.""" + import csv + + # 9(a): Unallocated GPU curves + path = os.path.join(output_dir, 'figure9a_unalloc.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'arrived_pct', 'unalloc_gpu_pct', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for x, y in r.unalloc_curve: + writer.writerow([name, x, y, run_idx]) + + # 9(b): Occupied nodes curves + path = os.path.join(output_dir, 'figure9b_occupied.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'arrived_pct', 'occupied_nodes', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for x, y in r.occupied_curve: + writer.writerow([name, x, y, run_idx]) + + # 9(c): Failed task breakdown + path = os.path.join(output_dir, 'figure9c_failed.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'gpu_category', 'sum_gpu_demand', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for cat, val in r.failed_by_category.items(): + writer.writerow([name, cat, val, run_idx]) + + # 9(d): Fragmentation breakdown + path = os.path.join(output_dir, 'figure9d_breakdown.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'cause', 'pct', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for cause, pct in r.frag_breakdown.items(): + writer.writerow([name, cause, pct, run_idx]) + + print(f"Figure 9 CSV files saved to {output_dir}") + + +def load_figure9_results_from_csv(csv_dir: str) -> Dict[str, List[ExperimentResult]]: + """Load Figure 9 artifacts from CSV files in a directory.""" + import csv + + def load_curve_csv(filename: str, x_col: str, y_col: str): + path = os.path.join(csv_dir, filename) + if not os.path.exists(path): + return {} + data = defaultdict(lambda: defaultdict(list)) + with open(path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + name = row['scheduler'] + run = int(row['run']) + data[name][run].append((float(row[x_col]), float(row[y_col]))) + return data + + def load_cat_csv(filename: str, cat_col: str, val_col: str): + path = os.path.join(csv_dir, filename) + if not os.path.exists(path): + return {} + data = defaultdict(lambda: defaultdict(dict)) + with open(path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + name = row['scheduler'] + run = int(row['run']) + data[name][run][row[cat_col]] = float(row[val_col]) + return data + + unalloc = load_curve_csv('figure9a_unalloc.csv', 'arrived_pct', 'unalloc_gpu_pct') + occupied = load_curve_csv('figure9b_occupied.csv', 'arrived_pct', 'occupied_nodes') + failed = load_cat_csv('figure9c_failed.csv', 'gpu_category', 'sum_gpu_demand') + breakdown = load_cat_csv('figure9d_breakdown.csv', 'cause', 'pct') + + results: Dict[str, List[ExperimentResult]] = {} + all_names = set(unalloc) | set(occupied) | set(failed) | set(breakdown) + for name in all_names: + runs = set() + for data in (unalloc, occupied, failed, breakdown): + if name in data: + runs |= set(data[name].keys()) + + results[name] = [] + for run_idx in sorted(runs): + r = ExperimentResult(scheduler_name=name) + if name in unalloc and run_idx in unalloc[name]: + r.unalloc_curve = sorted(unalloc[name][run_idx]) + if name in occupied and run_idx in occupied[name]: + r.occupied_curve = sorted(occupied[name][run_idx]) + if name in failed and run_idx in failed[name]: + r.failed_by_category = failed[name][run_idx] + if name in breakdown and run_idx in breakdown[name]: + r.frag_breakdown = breakdown[name][run_idx] + results[name].append(r) + + return results + + +def plot_figure9(results: Dict[str, List[ExperimentResult]], output_dir: str): + """Plot Figure 9 (a-d) and save to figure9.png.""" + try: + import matplotlib + import matplotlib.pyplot as plt + import numpy as np + import math + except ImportError: + print("matplotlib/numpy not installed. Skipping figure9 plot.") + return + + import re + + styles = { + 'Random': {'color': 'brown', 'linestyle': '-.'}, + 'DotProd': {'color': 'purple', 'linestyle': '-.'}, + 'Clustering': {'color': 'red', 'linestyle': '--'}, + 'Packing': {'color': 'green', 'linestyle': ':'}, + 'BestFit': {'color': 'orange', 'linestyle': '--'}, + 'BestFit-PN': {'color': '#fdbf6f', 'linestyle': '--'}, + 'FGD': {'color': 'black', 'linestyle': '-'}, + 'FGD-Full': {'color': '#1f77b4', 'linestyle': '-'}, + 'B-FGD': {'color': '#e377c2', 'linestyle': '--'}, + 'U-FGD': {'color': '#17becf', 'linestyle': '-.'}, + } + + # Distinct palette for FGD variants (FGD-, W-FGD-, and other FGD-prefixed names). + fgd_variant_colors = [ + '#000000', '#1f77b4', '#17becf', '#e377c2', '#7f7f7f', + '#bcbd22', '#2ca02c', '#9467bd', '#8c564b', '#ff7f0e' + ] + fgd_variant_styles = ['-', '--', '-.', ':'] + variant_style_map: Dict[str, Dict[str, str]] = {} + + variant_names = sorted( + [ + n for n in results.keys() + if re.fullmatch(r'FGD-\d+', n) or re.fullmatch(r'W-FGD-\d+', n) + or (n.startswith('FGD') and n not in styles) + ] + ) + for i, name in enumerate(variant_names): + variant_style_map[name] = { + 'color': fgd_variant_colors[i % len(fgd_variant_colors)], + 'linestyle': fgd_variant_styles[(i // len(fgd_variant_colors)) % len(fgd_variant_styles)] + } + + def _style_for(name: str) -> Dict[str, str]: + """Return plotting style, ensuring FGD variants are visually distinct.""" + if name in styles: + return styles[name] + if name in variant_style_map: + return variant_style_map[name] + return {'color': 'black', 'linestyle': '-'} + + # Reset any global style changes (e.g., from plot_figure7) and set Figure 9 sizes explicitly. + matplotlib.rcdefaults() + fig, axes = plt.subplots(4, 1, figsize=(5.9, 9), dpi=100) + + # 9(a): Unallocated GPU % + ax = axes[0] + all_x_9a: List[float] = [] + all_y_9a: List[float] = [] + averaged_curves_9a: Dict[str, List[Tuple[float, float]]] = {} + + for name, result_list in results.items(): + avg = _average_curves([r.unalloc_curve for r in result_list]) + if not avg: + continue + averaged_curves_9a[name] = avg + for x, y in avg: + all_x_9a.append(x) + all_y_9a.append(y) + + if all_x_9a: + x_min_9a = math.floor(min(all_x_9a) / 5.0) * 5 + x_max_9a = math.ceil(max(all_x_9a) / 5.0) * 5 + else: + x_min_9a, x_max_9a = 0, 120 + + ideal_x = list(range(int(x_min_9a), int(x_max_9a) + 1)) + ideal_y = [max(0, 100 - x) for x in ideal_x] + ax.plot(ideal_x, ideal_y, color='gray', linestyle=':', linewidth=1.5, label='Ideal') + + for name, avg in averaged_curves_9a.items(): + filtered = [(x, y) for x, y in avg if x_min_9a <= x <= x_max_9a] + if not filtered: + continue + style = _style_for(name) + ax.plot( + [p[0] for p in filtered], + [p[1] for p in filtered], + label=name, + color=style['color'], + linestyle=style['linestyle'], + linewidth=2 + ) + + # Dynamic axis range for 9(a) + if all_y_9a: + y_min_9a = 0 + y_max_9a = max(5, math.ceil((max(all_y_9a) * 1.10) / 5.0) * 5) + else: + y_min_9a, y_max_9a = 0, 25 + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)') + ax.set_ylabel('Unalloc. GPU (%)') + ax.tick_params(axis='both', labelsize=12) + ax.legend(fontsize=9, loc='center left', bbox_to_anchor=(1.02, 0.5), frameon=False) + ax.set_xlim(40, 100) + ax.set_xticks(np.arange(40, 100.1, 10)) + ax.set_ylim(0, 70) + ax.set_yticks(np.arange(0, 70.1, 10)) + ax.grid(True, linestyle='--', alpha=0.35) + + # 9(b): Occupied nodes + ax = axes[1] + for name, result_list in results.items(): + avg = _average_curves([r.occupied_curve for r in result_list]) + if not avg: + continue + filtered = [(x, y) for x, y in avg if x >= 0] + if not filtered: + continue + if filtered[0][0] > 0: + filtered = [(0.0, 0.0)] + filtered + style = _style_for(name) + ax.plot( + [p[0] for p in filtered], + [p[1] for p in filtered], + label=name, + color=style['color'], + linestyle=style['linestyle'], + linewidth=2 + ) + + # Dynamic axis range for 9(b) + all_x_9b: List[float] = [] + all_y_9b: List[float] = [] + for result_list in results.values(): + avg = _average_curves([r.occupied_curve for r in result_list]) + for x, y in avg: + all_x_9b.append(x) + all_y_9b.append(y) + if all_x_9b: + x_min_9b = max(0.0, math.floor(min(all_x_9b) / 5.0) * 5) + x_max_9b = math.ceil(max(all_x_9b) / 5.0) * 5 + else: + x_min_9b, x_max_9b = 0, 100 + if all_y_9b: + y_min_9b = 0 + y_max_9b = max(10, math.ceil((max(all_y_9b) * 1.10) / 50.0) * 50) + else: + y_min_9b, y_max_9b = 0, 1000 + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)') + ax.set_ylabel('Occupied nodes') + ax.tick_params(axis='both', labelsize=12) + ax.legend(fontsize=9, loc='center left', bbox_to_anchor=(1.02, 0.5), frameon=False) + ax.set_xlim(x_min_9b, x_max_9b) + xtick_step_9b = 10 if (x_max_9b - x_min_9b) <= 80 else 20 + ax.set_xticks(np.arange(x_min_9b, x_max_9b + 0.1, xtick_step_9b)) + ax.set_ylim(y_min_9b, y_max_9b) + ytick_step_9b = 100 if y_max_9b <= 800 else 250 + ax.set_yticks(np.arange(y_min_9b, y_max_9b + 0.1, ytick_step_9b)) + ax.grid(True, linestyle='--', alpha=0.35) + + # Fixed scheduler order for bar charts + bar_order = ['FGD', 'FGD-Full', 'B-FGD', 'U-FGD', 'BestFit', 'BestFit-PN', 'Packing', 'Clustering', 'DotProd', 'Random'] + scheduler_names = [n for n in bar_order if n in results] + # Always append any additional schedulers (e.g., FGD-500, W-FGD-500, custom names). + scheduler_names.extend([n for n in results.keys() if n not in scheduler_names]) + x_pos = np.arange(len(scheduler_names)) + + # 9(c): Failed tasks by category + ax = axes[2] + categories = ['<1', '1', '2', '8'] # bottom -> top + cat_colors = {'<1': 'orange', '1': 'green', '2': 'red', '8': '#8c564b'} + + bottoms = np.zeros(len(scheduler_names)) + cat_handles = {} + for cat in categories: + values = [] + for name in scheduler_names: + avg_val = sum(r.failed_by_category.get(cat, 0) for r in results[name]) / len(results[name]) + values.append(avg_val) + cat_handles[cat] = ax.bar( + x_pos, values, bottom=bottoms, label=cat, + color=cat_colors[cat], edgecolor='0', linewidth=0.3 + ) + bottoms += np.array(values) + + ax.set_xticks(x_pos) + ax.set_xticklabels(scheduler_names, rotation=0, fontsize=10) + ax.set_ylabel('Sum of Pending Task GPUs') + ax.set_title('When arrived workloads equals 96% GPU capacity', fontsize=11) + ax.tick_params(axis='y', labelsize=11) + max_stack_9c = float(max(bottoms)) if len(bottoms) > 0 else 0.0 + y_max_9c = max(10, math.ceil((max_stack_9c * 1.10) / 50.0) * 50) + ax.set_ylim(0, y_max_9c) + # Keep exactly 10 intervals on y-axis (11 ticks including 0 and max). + ax.set_yticks(np.linspace(0, y_max_9c, 11)) + legend_order_top_to_bottom = ['8', '2', '1', '<1'] + ax.legend( + handles=[cat_handles[c][0] for c in legend_order_top_to_bottom], + labels=legend_order_top_to_bottom, + title='Task GPU Req', + fontsize=8, + title_fontsize=9, + loc='upper left', + frameon=True, + borderpad=0.6, + handlelength=1.6, + handletextpad=0.6, + labelspacing=0.4, + ) + ax.grid(True, linestyle='--', alpha=0.35, axis='y') + + # 9(d): fragmentation breakdown + ax = axes[3] + causes = ['deficient', 'stranded', 'non_gpu'] + cause_colors = {'deficient': 'blue', 'stranded': 'orange', 'non_gpu': 'green'} + cause_labels = {'deficient': 'Deficient', 'stranded': 'Stranded', 'non_gpu': 'Non-GPU'} + + bottoms = np.zeros(len(scheduler_names)) + for cause in causes: + values = [] + for name in scheduler_names: + avg_val = sum(r.frag_breakdown.get(cause, 0) for r in results[name]) / len(results[name]) + values.append(avg_val) + ax.bar( + x_pos, values, bottom=bottoms, label=cause_labels[cause], + color=cause_colors[cause], edgecolor='0', linewidth=0.3 + ) + bottoms += np.array(values) + + ax.set_xticks(x_pos) + ax.set_xticklabels(scheduler_names, rotation=0, fontsize=10) + ax.set_ylabel('Fragmented GPUs (%)') + ax.tick_params(axis='y', labelsize=11) + ax.legend(fontsize=9, loc='lower left', frameon=True) + ax.set_ylim(0, 100) + ax.set_yticks([0, 25, 50, 75, 100]) + ax.grid(True, linestyle='--', alpha=0.35, axis='y') + + fig.subplots_adjust(left=0.10, right=0.98, top=0.98, bottom=0.07, hspace=1.05) + + # 9(a)/(b) slightly narrower to leave legend room + left = 0.10 + right_line = 0.82 + right_bar = 0.98 + for i in [0, 1]: + p = axes[i].get_position() + axes[i].set_position([left, p.y0, right_line - left, p.height]) + for i in [2, 3]: + p = axes[i].get_position() + axes[i].set_position([left, p.y0, right_bar - left, p.height]) + + captions = [ + "(a) The percentage of unallocated GPUs given arriving workloads.", + "(b) The number of GPU nodes occupied during the scheduling.", + "(c) GPU requests of failed tasks when the cluster is almost full\n(i.e., cumulative GPU requests reach 96% of the cluster capacity).", + "(d) The breakdown of GPU fragmentation into three causes.", + ] + caption_offsets = [0.060, 0.060, 0.050, 0.045] + for i, cap in enumerate(captions): + p = axes[i].get_position() + fig.text(0.5, p.y0 - caption_offsets[i], cap, ha='center', va='top', fontsize=9) + + path = os.path.join(output_dir, 'figure9.png') + plt.savefig(path, dpi=150, bbox_inches='tight') + plt.close(fig) + print(f"Figure 9 plot saved to {path}") + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Distribution-Shift Experiment - Trace Replay") + parser.add_argument('--task-order', choices=['trace', 'ascending', 'descending', 'phased'], default='trace', + help='Task arrival order: trace (original), ascending/descending (sorted by GPU type), phased (GPU tier phases)') + parser.add_argument('--cluster-scale', type=float, default=100.0, + help='Cluster size as %% of original (e.g., 50 keeps 50%% of each node type)') + parser.add_argument('--tier-order', type=str, default='0,1,2,3,4', + help='Tier order for phased mode (comma-separated, e.g., 3,2,1,4,0)') + parser.add_argument('--prior-strength', type=float, default=10.0, + help='Prior strength for B-FGD (pseudo-count total, default: 10)') + parser.add_argument('--min-gpu-tasks', type=int, default=50, + help='B-FGD uses Packing fallback until this many GPU tasks observed (default: 50)') + parser.add_argument('--fgd-popularity-threshold', type=float, default=95, + help='Top-N%% typical pod popularity threshold used for FGD scoring (default: 95)') + parser.add_argument('--sample-interval-pct', type=float, default=2.0, + help='Figure 9 sample interval in arrived GPU %% (default: 2)') + parser.add_argument('--max-arrival-pct', type=float, default=120.0, + help='Stop replay when cumulative GPU requests reach this %% of cluster capacity (default: 120)') + parser.add_argument('--snapshot-pct', type=float, default=96.0, + help='Figure 9(c) snapshot point in arrived GPU %% (default: 96)') + parser.add_argument('--no-plot', action='store_true', + help='Skip generating figure9.png (still saves CSVs)') + parser.add_argument('--plot-only', action='store_true', + help='Only regenerate figure9.png from existing CSV files') + parser.add_argument('--plot-csv', type=str, default=None, + help='CSV directory for --plot-only (default: inferred result dir)') + parser.add_argument('--schedulers', type=str, default='all', + help='Comma-separated scheduler names to run (default: all). ' + 'Baselines: Random,BestFit,DotProd,Packing,Clustering. ' + 'FGD variants: FGD-Full, FGD- (first-N distribution, e.g. FGD-500), ' + 'W-FGD- (sliding window size M, e.g. W-FGD-200), B-FGD, U-FGD. ' + 'For FGD-/W-FGD-, N/M are parsed from the name.') + args = parser.parse_args() + + # Parse tier order + args.tier_order_list = [int(x) for x in args.tier_order.split(',')] + + # Result directory naming (shared by normal and plot-only mode) + scale_str = f"{args.cluster_scale:g}" + order_str = args.task_order + if args.task_order == 'phased': + order_str = f"phased-{''.join(str(x) for x in args.tier_order_list)}" + result_name = f"dist-shift-{order_str}-{scale_str}" + result_dir = os.path.join(os.path.dirname(__file__), 'result', result_name) + + # Plot-only mode: load CSV artifacts and regenerate figure9.png. + if args.plot_only: + csv_dir = args.plot_csv if args.plot_csv else result_dir + plotted_any = False + + fig7_csv = os.path.join(csv_dir, 'figure7_results.csv') + if os.path.exists(fig7_csv): + fig7_results = load_figure7_results_from_csv(fig7_csv) + if fig7_results: + print(f"Loaded {len(fig7_results)} schedulers for Figure 7 from {fig7_csv}") + plot_figure7(fig7_results, csv_dir) + plotted_any = True + + fig9_results = load_figure9_results_from_csv(csv_dir) + if fig9_results: + print(f"Loaded {len(fig9_results)} schedulers for Figure 9 from {csv_dir}") + plot_figure9(fig9_results, csv_dir) + plotted_any = True + + if not plotted_any: + print(f"No Figure 7/9 CSV data found in {csv_dir}") + exit(1) + exit(0) + + # Run the experiment + data_dir = os.path.join(os.path.dirname(__file__), '..', 'alibaba_traces', 'cluster-trace-gpu-v2023') + + print("=" * 60) + print("Distribution-Shift Experiment - Trace Replay") + print(f" task_order={args.task_order}") + if args.task_order == 'phased': + print(f" tier_order={args.tier_order}") + print(f" cluster_scale={args.cluster_scale}%") + print("=" * 60) + + experiment = DistShiftExperiment( + data_dir, + task_order=args.task_order, cluster_scale=args.cluster_scale, + tier_order=args.tier_order_list, + fgd_popularity_threshold=args.fgd_popularity_threshold + ) + + # Build scheduler list + if args.schedulers == 'all': + fgd_full = FGDScheduler() + fgd_full.name = "FGD-Full" + fgd_n = FGDScheduler( + scheduling_task_types=experiment.first_n_distribution.get_task_types() + ) + fgd_n.name = f"FGD-{experiment.window_size}" + w_fgd = WindowedFGDScheduler(window_size=experiment.window_size) + b_fgd = BayesianFGDScheduler(prior_strength=args.prior_strength, + min_gpu_tasks=args.min_gpu_tasks) + uniform_types = build_uniform_task_types(experiment.loader.nodes) + u_fgd = FGDScheduler(scheduling_task_types=uniform_types) + u_fgd.name = "U-FGD" + baselines = [s for s in get_all_schedulers() if not isinstance(s, FGDScheduler)] + schedulers = baselines + [fgd_full, fgd_n, w_fgd, b_fgd, u_fgd] + else: + # For explicit names, N/M are parsed directly from the scheduler name. + selected = [s.strip() for s in args.schedulers.split(',')] + schedulers = [] + for name in selected: + sched = build_scheduler(name, experiment, + args.prior_strength, args.min_gpu_tasks) + if sched is not None: + schedulers.append(sched) + else: + print(f"WARNING: Unknown scheduler '{name}'. " + f"Available: Random, BestFit, DotProd, Packing, Clustering, " + f"FGD-Full, FGD-, W-FGD-, B-FGD, U-FGD") + if not schedulers: + print("No valid schedulers selected. Exiting.") + exit(1) + + import re as _re + for s in schedulers: + m = _re.fullmatch(r'FGD-(\d+)', s.name) + if m: + n = int(m.group(1)) + n_types = len(experiment._compute_initial_distribution(n).get_task_types()) + print(f"First-{n} distribution ({s.name}): {n_types} task types") + if any(isinstance(s, BayesianFGDScheduler) for s in schedulers): + print(f" prior_strength={args.prior_strength}, min_gpu_tasks={args.min_gpu_tasks}") + + # Run trace replay + results = experiment.run_experiment( + schedulers=schedulers, + sample_interval_pct=args.sample_interval_pct, + max_arrival_pct=args.max_arrival_pct, + snapshot_pct=args.snapshot_pct, + ) + + # Create result directory + os.makedirs(result_dir, exist_ok=True) + + # Print summary + print_summary(results) + + # Save summary log + log_path = os.path.join(result_dir, 'experiment_summary.log') + with open(log_path, 'w') as f: + f.write(f"Experiment: Distribution-Shift - Trace Replay\n") + f.write(f"Result: {result_name}\n") + f.write(f"Mode: replay\n") + f.write(f"FGD popularity threshold: {args.fgd_popularity_threshold}\n") + f.write(f"Figure9 sample interval (%): {args.sample_interval_pct}\n") + f.write(f"Figure9 max arrival (%): {args.max_arrival_pct}\n") + f.write(f"Figure9 snapshot (%): {args.snapshot_pct}\n") + if any(isinstance(s, BayesianFGDScheduler) for s in schedulers): + f.write(f"Prior strength (B-FGD): {args.prior_strength}\n") + f.write(f"Min GPU tasks (B-FGD): {args.min_gpu_tasks}\n") + f.write(f"Task order: {args.task_order}\n") + if args.task_order == 'phased': + f.write(experiment.phase_info + "\n") + f.write(f"Cluster: {experiment.original_node_count} nodes -> {experiment.scaled_node_count} nodes ({args.cluster_scale}%)\n") + f.write(f"Full distribution: {len(experiment.full_task_distribution.get_task_types())} task types\n") + f.write( + f"FGD scoring distribution (top {args.fgd_popularity_threshold:g}%): " + f"{len(experiment.fgd_scoring_distribution.get_task_types())} task types\n" + ) + import re as _re + for s in schedulers: + m = _re.fullmatch(r'FGD-(\d+)', s.name) + if m: + n = int(m.group(1)) + n_types = len(experiment._compute_initial_distribution(n).get_task_types()) + f.write( + f"First-{n} distribution ({s.name}, top {args.fgd_popularity_threshold:g}%): " + f"{n_types} task types\n" + ) + f.write("\n") + f.write(format_summary(results) + "\n") + print(f"Summary log saved to {log_path}") + + # Save and plot Figure 7 artifacts from the same replay. + save_figure7_results_to_csv(results, result_dir) + + # Save and plot Figure 9 artifacts from the same replay. + save_figure9_results_to_csv(results, result_dir) + if not args.no_plot: + plot_figure7(results, result_dir) + plot_figure9(results, result_dir) diff --git a/standalone_fgd_replication/exp_fig11_14.py b/standalone_fgd_replication/exp_fig11_14.py new file mode 100644 index 0000000..ce1fbf4 --- /dev/null +++ b/standalone_fgd_replication/exp_fig11_14.py @@ -0,0 +1,630 @@ +""" +Experiment 3: Sensitivity Analysis (Figures 11-14) + +Figure 11 (Section 6.3): Varying GPU-sharing task proportion +Figure 12 (Section 6.4): Varying multi-GPU task proportion +Figure 13 (Section 6.5): Varying GPU-type constrained task proportion +Figure 14 (Section 6.6): Varying non-GPU task proportion + +Each figure loads pre-built trace files from the Alibaba cluster-trace-gpu-v2023 +dataset that already encode the desired workload mix: + Fig 11: openb_pod_list_gpushare{40,60,80,100}.csv + Fig 12: openb_pod_list_multigpu{20,30,40,50}.csv + Fig 13: openb_pod_list_gpuspec{10,20,25,33}.csv + Fig 14: openb_pod_list_cpu{050,100,200,250}.csv (5/10/20/25% non-GPU) + +All figures use Monte-Carlo workload inflation: +- Sample tasks with replacement until GPU requests reach 100% of cluster capacity +- Measure unallocated GPU % +- Repeat N runs, average results +""" + +import os +import random +from typing import List, Dict, Tuple, Optional +from dataclasses import dataclass, field + +from simulator import Task, Node, Cluster, TaskDistribution +from schedulers import ( + Scheduler, get_all_schedulers, get_all_schedulers_with_bestfit_variants, + ClusteringScheduler, FGDScheduler +) +from trace_loader import AlibabaTraceLoader + + +# --------------------------------------------------------------------------- +# GPU-type aware cluster (Figure 13) +# --------------------------------------------------------------------------- + +class GpuTypeAwareCluster(Cluster): + """Cluster subclass that enforces GPU-type placement constraints. + + When a task has gpu_spec set, it can only be scheduled on nodes + whose gpu_model matches. + """ + + def get_eligible_nodes(self, task: Task) -> List[Node]: + eligible = super().get_eligible_nodes(task) + if task.gpu_spec: + allowed = set(task.gpu_spec.split('|')) + eligible = [n for n in eligible if n.gpu_model in allowed] + return eligible + + +# --------------------------------------------------------------------------- +# File mapping +# --------------------------------------------------------------------------- + +FIGURE_FILES: Dict[int, Dict[int, str]] = { + 11: { + 40: 'openb_pod_list_gpushare40.csv', + 60: 'openb_pod_list_gpushare60.csv', + 80: 'openb_pod_list_gpushare80.csv', + 100: 'openb_pod_list_gpushare100.csv', + }, + 12: { + 20: 'openb_pod_list_multigpu20.csv', + 30: 'openb_pod_list_multigpu30.csv', + 40: 'openb_pod_list_multigpu40.csv', + 50: 'openb_pod_list_multigpu50.csv', + }, + 13: { + 10: 'openb_pod_list_gpuspec10.csv', + 20: 'openb_pod_list_gpuspec20.csv', + 25: 'openb_pod_list_gpuspec25.csv', + 33: 'openb_pod_list_gpuspec33.csv', + }, + 14: { + 5: 'openb_pod_list_cpu050.csv', + 10: 'openb_pod_list_cpu100.csv', + 20: 'openb_pod_list_cpu200.csv', + 25: 'openb_pod_list_cpu250.csv', + }, +} + +FIGURE_CONFIG = { + 11: { + 'name': 'GPU-Sharing Task Proportion', + 'section': '6.3', + 'xlabel': 'Proportion of GPU-sharing workloads\n(% of GPU requests)', + 'proportions': [40, 60, 80, 100], + 'gpu_type_aware': False, + }, + 12: { + 'name': 'Multi-GPU Task Proportion', + 'section': '6.4', + 'xlabel': 'Proportion of multi-GPU workloads\n(% of GPU requests)', + 'proportions': [20, 30, 40, 50], + 'gpu_type_aware': False, + }, + 13: { + 'name': 'GPU-Type Constrained Task Proportion', + 'section': '6.5', + 'xlabel': 'Proportion with GPU type constraints\n(% of GPU requests)', + 'proportions': [10, 20, 25, 33], + 'gpu_type_aware': True, + }, + 14: { + 'name': 'Non-GPU Task Proportion', + 'section': '6.6', + 'xlabel': 'Proportion of non-GPU workloads\n(% of task number)', + 'proportions': [5, 10, 20, 25], + 'gpu_type_aware': False, + }, +} + + +# --------------------------------------------------------------------------- +# Data classes +# --------------------------------------------------------------------------- + +@dataclass +class SensitivityResult: + """Result for one (scheduler, proportion) combination, averaged over runs.""" + scheduler_name: str + proportion: float + unalloc_gpu_pct: float + unalloc_std: float = 0.0 + + +# --------------------------------------------------------------------------- +# Main experiment class +# --------------------------------------------------------------------------- + +class SensitivityExperiment: + """Runs sensitivity experiments for Figures 11-14.""" + + def __init__(self, data_dir: str, fgd_popularity_threshold: float = 95): + self.data_dir = data_dir + self.fgd_popularity_threshold = fgd_popularity_threshold + self.csv_dir = os.path.join(data_dir, 'csv') + + # Load nodes once (shared across all figures) + self.loader = AlibabaTraceLoader(data_dir) + self.loader.load_nodes() + + self.total_gpu_capacity = sum(n.num_gpus for n in self.loader.nodes) + + print(f"Loaded cluster: {len(self.loader.nodes)} nodes, " + f"{self.total_gpu_capacity} GPUs") + + # ------------------------------------------------------------------ + # Helpers + # ------------------------------------------------------------------ + + def load_tasks(self, filename: str) -> List[Task]: + """Load tasks from a specific trace CSV file.""" + self.loader.load_tasks(filename=filename) + return self.loader.tasks + + def _compute_task_distribution(self, tasks: List[Task], popularity_threshold: float = None) -> TaskDistribution: + """Compute task type distribution from a task list. + + If popularity_threshold is set, keep top task types by frequency until + cumulative count reaches the threshold percentage, then renormalize. + """ + from collections import Counter + type_counts: Counter = Counter() + for t in tasks: + gpu_rounded = round(t.gpu_demand, 2) + cpu_bucket = round(t.cpu_demand / 4) * 4 + type_counts[(cpu_bucket, gpu_rounded)] += 1 + + total = sum(type_counts.values()) + if popularity_threshold is not None: + expected = popularity_threshold * total / 100.0 + sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True) + selected = {} + cum = 0 + for type_key, count in sorted_types: + selected[type_key] = count + cum += count + if cum >= expected: + break + dist = TaskDistribution() + for (cpu, gpu), count in selected.items(): + dist.add_task_type(cpu, gpu, count / cum) + return dist + + dist = TaskDistribution() + for (cpu, gpu), count in type_counts.items(): + dist.add_task_type(cpu, gpu, count / total) + return dist + + def _compute_task_distribution_typed(self, tasks: List[Task], popularity_threshold: float = None) -> List: + """Compute task type distribution with gpu_spec included. + + Returns a list of ((cpu, gpu, gpu_spec), popularity) tuples suitable + for GPU-type-aware FGD fragmentation computation. Tasks with no + gpu_spec get an empty string, meaning they are compatible with any + node type. + """ + from collections import Counter + type_counts: Counter = Counter() + for t in tasks: + gpu_rounded = round(t.gpu_demand, 2) + cpu_bucket = round(t.cpu_demand / 4) * 4 + gpu_spec = t.gpu_spec or '' + type_counts[(cpu_bucket, gpu_rounded, gpu_spec)] += 1 + total = sum(type_counts.values()) + if popularity_threshold is not None: + expected = popularity_threshold * total / 100.0 + sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True) + selected = {} + cum = 0 + for type_key, count in sorted_types: + selected[type_key] = count + cum += count + if cum >= expected: + break + return [((cpu, gpu, spec), count / cum) + for (cpu, gpu, spec), count in selected.items()] + + return [((cpu, gpu, spec), count / total) + for (cpu, gpu, spec), count in type_counts.items()] + + def create_fresh_cluster(self, gpu_type_aware: bool = False) -> Cluster: + cls = GpuTypeAwareCluster if gpu_type_aware else Cluster + cluster = cls() + for i, orig in enumerate(self.loader.nodes): + cluster.add_node(Node( + node_id=i, total_cpu=orig.total_cpu, + num_gpus=orig.num_gpus, name=orig.name, + gpu_model=orig.gpu_model, memory_mib=orig.memory_mib)) + return cluster + + # ------------------------------------------------------------------ + # Run methods + # ------------------------------------------------------------------ + + def run_single(self, scheduler: Scheduler, tasks: List[Task], + dist: TaskDistribution, seed: int, + gpu_type_aware: bool = False) -> float: + """Run single Monte-Carlo inflation until 100% GPU arrival. + + Returns unallocated GPU % at that point. + """ + rng = random.Random(seed) + cluster = self.create_fresh_cluster(gpu_type_aware=gpu_type_aware) + cluster.set_task_distribution(dist) + + if isinstance(scheduler, ClusteringScheduler): + scheduler.reset() + + cumulative_gpu = 0.0 + max_gpu = float(self.total_gpu_capacity) + task_count = 0 + + while cumulative_gpu < max_gpu: + orig = rng.choice(tasks) + task = Task( + task_id=task_count, + cpu_demand=orig.cpu_demand, + gpu_demand=orig.gpu_demand, + gpu_spec=orig.gpu_spec if gpu_type_aware else '') + task_count += 1 + cumulative_gpu += task.gpu_demand + scheduler.schedule(task, cluster) + + return (cluster.total_unallocated_gpu / self.total_gpu_capacity) * 100 + + def run_figure(self, figure_num: int, schedulers: List[Scheduler], + num_runs: int = 10, seed: int = 42, + proportions: List[float] = None, + show_progress: bool = True + ) -> Dict[float, List[SensitivityResult]]: + """Run one figure experiment across all proportions and schedulers.""" + from tqdm import tqdm + + config = FIGURE_CONFIG[figure_num] + gpu_type_aware = config['gpu_type_aware'] + if proportions is None: + proportions = config['proportions'] + + file_map = FIGURE_FILES[figure_num] + + results: Dict[float, List[SensitivityResult]] = {} + total_runs = len(proportions) * len(schedulers) * num_runs + pbar = tqdm(total=total_runs, desc=f"Figure {figure_num}", + disable=not show_progress, ncols=90) + + for pct in proportions: + filename = file_map[pct] + tasks = self.load_tasks(filename) + # Full distribution is used for evaluation metrics. + dist = self._compute_task_distribution(tasks) + # Paper script default for typical pods is 95%; use this for FGD scoring. + fgd_dist = self._compute_task_distribution( + tasks, popularity_threshold=self.fgd_popularity_threshold) + print(f"\n [{figure_num}] {pct}% — {filename} ({len(tasks)} tasks)") + + # For GPU-type-constrained figure, give FGD a typed distribution + # so it can account for GPU type compatibility in its gradient. + typed_dist = (self._compute_task_distribution_typed(tasks) + if gpu_type_aware else None) + typed_fgd_dist = (self._compute_task_distribution_typed( + tasks, popularity_threshold=self.fgd_popularity_threshold) + if gpu_type_aware else None) + for s in schedulers: + if isinstance(s, FGDScheduler): + s.scheduling_task_types = fgd_dist.get_task_types() + s.typed_task_types = typed_fgd_dist + + results[pct] = [] + + for scheduler in schedulers: + unallocs = [] + for run_idx in range(num_runs): + run_seed = seed + run_idx + val = self.run_single( + scheduler, tasks, dist, run_seed, + gpu_type_aware=gpu_type_aware) + unallocs.append(val) + pbar.update(1) + pbar.set_postfix_str( + f"{pct}% {scheduler.name}", refresh=False) + + avg = sum(unallocs) / len(unallocs) + std = (sum((x - avg) ** 2 for x in unallocs) + / len(unallocs)) ** 0.5 + results[pct].append(SensitivityResult( + scheduler_name=scheduler.name, + proportion=pct, + unalloc_gpu_pct=avg, + unalloc_std=std)) + + pbar.close() + return results + + +# --------------------------------------------------------------------------- +# Plotting +# --------------------------------------------------------------------------- + +def plot_sensitivity(results: Dict[float, List[SensitivityResult]], + figure_num: int, output_dir: str = None): + """Grouped bar chart for one figure (paper style).""" + try: + import matplotlib + import matplotlib.pyplot as plt + import numpy as np + except ImportError: + print("matplotlib/numpy not installed. Skipping plot.") + return + + config = FIGURE_CONFIG[figure_num] + + colors = { + 'FGD': '#1f77b4', 'BestFit': '#ff7f0e', 'BestFit-PN': '#fdbf6f', + 'Packing': '#2ca02c', 'Clustering': '#d62728', + 'DotProd': '#9467bd', 'Random': '#8c564b', + } + hatches = { + 'FGD': '//', 'BestFit': '//', 'BestFit-PN': 'xx', + 'Packing': '//', 'Clustering': '//', 'DotProd': '//', 'Random': '//', + } + sched_order = ['FGD', 'BestFit', 'BestFit-PN', 'Packing', 'Clustering', + 'DotProd', 'Random'] + + proportions = sorted(results.keys()) + available = [r.scheduler_name for r in results[proportions[0]]] + sched_names = [s for s in sched_order if s in available] + + n_groups = len(proportions) + n_bars = len(sched_names) + bar_width = 0.12 + + matplotlib.rcdefaults() + matplotlib.rcParams['pdf.fonttype'] = 42 + matplotlib.rcParams.update({"font.size": 14}) + matplotlib.rcParams['lines.linewidth'] = 2 + + fig, ax = plt.subplots(figsize=(10, 3), dpi=120) + + for i, name in enumerate(sched_names): + x_positions = [] + values = [] + stds = [] + for j, pct in enumerate(proportions): + r = next((r for r in results[pct] + if r.scheduler_name == name), None) + if r: + x_positions.append(j + (i - n_bars / 2 + 0.5) * bar_width) + values.append(r.unalloc_gpu_pct) + stds.append(r.unalloc_std) + + bars = ax.bar(x_positions, values, bar_width, + label=name, + color=colors.get(name, 'gray'), + hatch=hatches.get(name, ''), + edgecolor='0', linewidth=0.5, + yerr=stds, + error_kw={'ecolor': 'gray', 'capsize': 3, + 'elinewidth': 1.2, 'capthick': 1.2}) + + # Match paper-style labeling: only annotate FGD bars. + if name == 'FGD': + ax.bar_label(bars, label_type='edge', fmt='%.1f%%', padding=5) + + ax.set_xticks(range(n_groups)) + ax.set_xticklabels([f'{int(p)}%' for p in proportions]) + ax.set_xlabel(config['xlabel']) + ax.set_ylabel('Unallocated GPU (%)') + ax.set_title('') + ax.set_ylim(0, 21.7) + ax.set_yticks([0, 5, 10, 15, 20]) + ax.grid(linestyle='-.', alpha=0.8, axis='y') + # Keep legend low and compact across Figures 11-14. + # Target placement: legend top edge around the y=5 dashed gridline. + ax.legend( + ncol=3, + fontsize=7, + loc='upper left', + frameon=True, + ) + plt.tight_layout() + + if output_dir: + path = os.path.join(output_dir, f'figure{figure_num}.png') + plt.savefig(path, dpi=150, bbox_inches='tight') + print(f" Plot saved to {path}") + plt.show() + + +# --------------------------------------------------------------------------- +# CSV / summary helpers +# --------------------------------------------------------------------------- + +def save_results_to_csv(results: Dict[float, List[SensitivityResult]], + figure_num: int, output_dir: str): + import csv + path = os.path.join(output_dir, f'figure{figure_num}_results.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['proportion', 'scheduler', 'unalloc_gpu_pct', 'std']) + for pct in sorted(results.keys()): + for r in results[pct]: + writer.writerow([pct, r.scheduler_name, + f'{r.unalloc_gpu_pct:.2f}', + f'{r.unalloc_std:.2f}']) + print(f" CSV saved to {path}") + + +def load_results_from_csv(csv_path: str + ) -> Tuple[int, Dict[float, List[SensitivityResult]]]: + """Load results from a CSV file produced by save_results_to_csv. + + Returns (figure_num, results_dict). + figure_num is inferred from the filename (e.g. figure12_results.csv -> 12). + """ + import csv + import re + + basename = os.path.basename(csv_path) + m = re.search(r'figure(\d+)', basename) + figure_num = int(m.group(1)) if m else 0 + + results: Dict[float, List[SensitivityResult]] = {} + with open(csv_path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + pct = float(row['proportion']) + if pct not in results: + results[pct] = [] + results[pct].append(SensitivityResult( + scheduler_name=row['scheduler'], + proportion=pct, + unalloc_gpu_pct=float(row['unalloc_gpu_pct']), + unalloc_std=float(row.get('std', 0)))) + + return figure_num, results + + +def format_summary(results: Dict[float, List[SensitivityResult]], + figure_num: int) -> str: + config = FIGURE_CONFIG[figure_num] + proportions = sorted(results.keys()) + sched_names = [r.scheduler_name for r in results[proportions[0]]] + + lines = [] + lines.append(f"Figure {figure_num} ({config['section']}): " + f"{config['name']}") + lines.append("=" * 70) + + header = f"{'Scheduler':<12}" + for pct in proportions: + header += f" {pct:>5.0f}%" + lines.append(header) + lines.append("-" * (12 + 8 * len(proportions))) + + for name in sched_names: + row = f"{name:<12}" + for pct in proportions: + r = next((r for r in results[pct] + if r.scheduler_name == name), None) + if r: + row += f" {r.unalloc_gpu_pct:>5.1f}%" + else: + row += f" {'N/A':>5}" + lines.append(row) + + return "\n".join(lines) + + +# --------------------------------------------------------------------------- +# Main +# --------------------------------------------------------------------------- + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser( + description="Sensitivity Analysis (Figures 11-14)") + parser.add_argument('--figures', type=str, default='11,12,13,14', + help='Comma-separated figure numbers ' + '(default: 11,12,13,14)') + parser.add_argument('--num-runs', type=int, default=10, + help='Monte-Carlo runs per configuration (default: 10)') + parser.add_argument('--seed', type=int, default=42, + help='Base random seed (default: 42)') + parser.add_argument('--plot-csv', type=str, nargs='+', default=None, + help='Plot from existing CSV file(s) instead of ' + 'running experiments. ' + 'e.g. --plot-csv result/exp3/figure11_results.csv') + parser.add_argument('--schedulers', type=str, default='all', + help='Comma-separated scheduler names to run (default: all). ' + 'Available: Random,BestFit,DotProd,Packing,Clustering,FGD') + parser.add_argument('--fgd-popularity-threshold', type=float, default=95.0, + help='Typical-pod popularity threshold (%) used for FGD scoring (default: 95)') + args = parser.parse_args() + + # ---- Plot-only mode ---- + if args.plot_csv: + for csv_path in args.plot_csv: + fig_num, results = load_results_from_csv(csv_path) + if fig_num == 0: + print(f"Warning: could not infer figure number from {csv_path}") + continue + output_dir = os.path.dirname(csv_path) or '.' + summary = format_summary(results, fig_num) + print(summary) + plot_sensitivity(results, fig_num, output_dir) + exit(0) + + # ---- Full experiment mode ---- + figures = [int(x) for x in args.figures.split(',')] + + data_dir = os.path.join(os.path.dirname(__file__), '..', + 'alibaba_traces', 'cluster-trace-gpu-v2023') + + print("=" * 60) + print("Sensitivity Analysis (Figures 11-14)") + print(f" Figures: {figures}") + print(f" Runs per config: {args.num_runs}") + print(f" Seed: {args.seed}") + print("=" * 60) + + experiment = SensitivityExperiment( + data_dir, + fgd_popularity_threshold=args.fgd_popularity_threshold, + ) + + all_sched_map = {s.name: s for s in get_all_schedulers_with_bestfit_variants()} + if args.schedulers == 'all': + schedulers = get_all_schedulers_with_bestfit_variants() + else: + selected = [s.strip() for s in args.schedulers.split(',')] + schedulers = [] + for name in selected: + if name in all_sched_map: + schedulers.append(all_sched_map[name]) + else: + print(f"WARNING: Unknown scheduler '{name}'. Available: {list(all_sched_map.keys())}") + if not schedulers: + print("No valid schedulers selected. Exiting.") + exit(1) + + # Result directory + fig_str = '-'.join(str(f) for f in figures) + result_name = f"fig{fig_str}-runs{args.num_runs}-seed{args.seed}" + result_dir = os.path.join(os.path.dirname(__file__), 'result', result_name) + os.makedirs(result_dir, exist_ok=True) + + all_summaries = [] + + for fig_num in figures: + config = FIGURE_CONFIG[fig_num] + print(f"\n{'=' * 60}") + print(f"Figure {fig_num} ({config['section']}): {config['name']}") + print(f" Proportions: {config['proportions']}") + print(f"{'=' * 60}") + + results = experiment.run_figure( + fig_num, schedulers, + num_runs=args.num_runs, seed=args.seed) + + summary = format_summary(results, fig_num) + print("\n" + summary) + all_summaries.append(summary) + + save_results_to_csv(results, fig_num, result_dir) + plot_sensitivity(results, fig_num, result_dir) + + # Combined summary log + log_path = os.path.join(result_dir, 'experiment_summary.log') + with open(log_path, 'w') as f: + f.write("Experiment: Sensitivity Analysis (Figures 11-14)\n") + f.write(f"Result: {result_name}\n") + f.write(f"Figures: {figures}\n") + f.write(f"Runs: {args.num_runs}\n") + f.write(f"Seed: {args.seed}\n") + f.write(f"Nodes: {len(experiment.loader.nodes)}\n") + f.write(f"GPUs: {experiment.total_gpu_capacity}\n\n") + for s in all_summaries: + f.write(s + "\n\n") + print(f"\nSummary log saved to {log_path}") + + # Cleanup FGD pools + for s in schedulers: + if isinstance(s, FGDScheduler): + s.cleanup() diff --git a/standalone_fgd_replication/exp_fig7.py b/standalone_fgd_replication/exp_fig7.py new file mode 100644 index 0000000..c3636e4 --- /dev/null +++ b/standalone_fgd_replication/exp_fig7.py @@ -0,0 +1,614 @@ +""" +Experiment Runner for FGD Replication + +Replicates Figure 7(a) and Figure 7(b): + 7(a): Fragmentation rate vs arrived workloads + 7(b): Fragmented GPUs / total resources vs arrived workloads +Using Monte-Carlo workload inflation approach from Section 6.1 +""" + +import os +import random +import copy +from typing import List, Dict, Tuple +from dataclasses import dataclass, field + +from simulator import Task, Node, Cluster, TaskDistribution +from schedulers import ( + Scheduler, get_all_schedulers, get_scheduler, + ClusteringScheduler, FGDScheduler +) +from trace_loader import AlibabaTraceLoader + + +@dataclass +class ExperimentResult: + """Results from a single experiment run""" + scheduler_name: str + # Figure 7(a): List of (arrived_workload_pct, fragmentation_rate) tuples + fragmentation_curve: List[Tuple[float, float]] = field(default_factory=list) + # Figure 7(b): List of (arrived_workload_pct, fragmented/total_gpu_pct) tuples + frag_total_curve: List[Tuple[float, float]] = field(default_factory=list) + # Final metrics + final_frag_rate: float = 0.0 + final_frag_total_pct: float = 0.0 + final_gpu_alloc_rate: float = 0.0 + tasks_scheduled: int = 0 + tasks_failed: int = 0 + + +class Figure7aExperiment: + """ + Replicates Figure 7(a) and Figure 7(b). + + Methodology (Monte-Carlo Workload Inflation from Section 6.1): + - Randomly sample tasks from trace with replacement + - Submit tasks until cumulative GPU requests reach target % of cluster capacity + - Track: + Figure 7(a): fragmentation rate (% of unallocated GPUs) + Figure 7(b): fragmented GPUs / total cluster GPUs (%) + """ + + def __init__(self, data_dir: str, seed: int = 42, fgd_popularity_threshold: float = 95): + """ + Initialize the experiment. + + Args: + data_dir: Path to data directory with Alibaba trace + seed: Random seed for reproducibility + """ + self.data_dir = data_dir + self.seed = seed + self.fgd_popularity_threshold = fgd_popularity_threshold + self.loader = AlibabaTraceLoader(data_dir) + + # Load trace data + self.loader.load_nodes() + self.loader.load_tasks() + + # Compute task distribution from trace + self.task_distribution = self.loader.compute_task_distribution() + # Paper's script default for typical pods is 95% popularity threshold. + self.fgd_scoring_distribution = self.loader.compute_task_distribution( + popularity_threshold=self.fgd_popularity_threshold + ) + + # Get cluster capacity + self.total_gpu_capacity = sum(n.num_gpus for n in self.loader.nodes) + + print(f"Loaded trace: {len(self.loader.nodes)} nodes, {self.total_gpu_capacity} GPUs") + print(f"Task pool: {len(self.loader.tasks)} tasks") + print(f"Task types (FGD scoring, top {self.fgd_popularity_threshold:.0f}%): " + f"{len(self.fgd_scoring_distribution.get_task_types())}") + + def create_fresh_cluster(self) -> Cluster: + """Create a fresh cluster with the same nodes as the trace""" + cluster = Cluster() + for i, orig_node in enumerate(self.loader.nodes): + node = Node( + node_id=i, + total_cpu=orig_node.total_cpu, + num_gpus=orig_node.num_gpus, + name=orig_node.name, + gpu_model=orig_node.gpu_model, + memory_mib=orig_node.memory_mib + ) + cluster.add_node(node) + cluster.set_task_distribution(self.task_distribution) + return cluster + + def sample_task(self, task_id: int) -> Task: + """Sample a random task from the trace (with replacement)""" + orig = random.choice(self.loader.tasks) + return Task( + task_id=task_id, + cpu_demand=orig.cpu_demand, + gpu_demand=orig.gpu_demand, + name=f"sampled-{task_id}", + gpu_spec=orig.gpu_spec + ) + + def run_single_experiment( + self, + scheduler: Scheduler, + max_workload_pct: float = 120.0, + sample_interval_pct: float = 5.0, + show_progress: bool = True + ) -> ExperimentResult: + """ + Run a single experiment with one scheduler. + + Args: + scheduler: The scheduling policy to use + max_workload_pct: Stop when arrived workload reaches this % of GPU capacity + sample_interval_pct: Record fragmentation every N% of arrived workload + show_progress: Whether to show progress bar + + Returns: + ExperimentResult with fragmentation curve + """ + from tqdm import tqdm + + cluster = self.create_fresh_cluster() + result = ExperimentResult(scheduler_name=scheduler.name) + + # Reset clustering scheduler state if needed + if isinstance(scheduler, ClusteringScheduler): + scheduler.reset() + if isinstance(scheduler, FGDScheduler): + scheduler.scheduling_task_types = self.fgd_scoring_distribution.get_task_types() + + cumulative_gpu_demand = 0.0 + task_id = 0 + next_sample_pct = sample_interval_pct + + # Estimate total tasks needed (based on average GPU demand) + avg_gpu_demand = sum(t.gpu_demand for t in self.loader.tasks) / len(self.loader.tasks) + estimated_tasks = int((max_workload_pct / 100) * self.total_gpu_capacity / max(avg_gpu_demand, 0.1)) + + pbar = tqdm( + total=int(max_workload_pct), + desc=f"{scheduler.name:12}", + unit="%", + disable=not show_progress, + ncols=80 + ) + + last_pct = 0 + while True: + # Sample a task + task = self.sample_task(task_id) + cumulative_gpu_demand += task.gpu_demand + task_id += 1 + + # Calculate arrived workload percentage + arrived_pct = (cumulative_gpu_demand / self.total_gpu_capacity) * 100 + + # Update progress bar + if int(arrived_pct) > last_pct: + pbar.update(int(arrived_pct) - last_pct) + last_pct = int(arrived_pct) + + # Try to schedule + if scheduler.schedule(task, cluster): + result.tasks_scheduled += 1 + else: + result.tasks_failed += 1 + + # Record fragmentation at intervals + if arrived_pct >= next_sample_pct: + frag_rate = cluster.compute_fragmentation_rate() + frag_total_pct = ( + cluster.compute_cluster_fragmentation() + / cluster.total_gpu_capacity + ) * 100.0 + result.fragmentation_curve.append((next_sample_pct, frag_rate)) + result.frag_total_curve.append((next_sample_pct, frag_total_pct)) + next_sample_pct += sample_interval_pct + + # Stop condition + if arrived_pct >= max_workload_pct: + break + + pbar.close() + + # Record final metrics + result.final_frag_rate = cluster.compute_fragmentation_rate() + result.final_frag_total_pct = ( + cluster.compute_cluster_fragmentation() / cluster.total_gpu_capacity + ) * 100.0 + result.final_gpu_alloc_rate = cluster.gpu_allocation_rate + + return result + + def run_experiment( + self, + schedulers: List[Scheduler] = None, + num_runs: int = 10, + max_workload_pct: float = 120.0, + sample_interval_pct: float = 5.0, + show_progress: bool = True + ) -> Dict[str, List[ExperimentResult]]: + """ + Run experiments for multiple schedulers with multiple runs. + + Args: + schedulers: List of schedulers to test (default: all) + num_runs: Number of runs per scheduler for averaging + max_workload_pct: Stop when arrived workload reaches this % + sample_interval_pct: Record fragmentation every N% + show_progress: Whether to show progress bar + + Returns: + Dict mapping scheduler name to list of results + """ + if schedulers is None: + schedulers = get_all_schedulers() + + results: Dict[str, List[ExperimentResult]] = {s.name: [] for s in schedulers} + + for run in range(num_runs): + # Set seed for this run (different seed per run, but consistent across schedulers) + random.seed(self.seed + run) + + print(f"\n=== Run {run + 1}/{num_runs} ===") + + for scheduler in schedulers: + # Reset seed to ensure same task sequence for fair comparison + random.seed(self.seed + run) + + # Reset scheduler state + if isinstance(scheduler, ClusteringScheduler): + scheduler.reset() + + result = self.run_single_experiment( + scheduler, + max_workload_pct=max_workload_pct, + sample_interval_pct=sample_interval_pct, + show_progress=show_progress + ) + results[scheduler.name].append(result) + + print(f" {scheduler.name:12}: Frag={result.final_frag_rate:.1f}%, " + f"Frag/Total={result.final_frag_total_pct:.1f}%, " + f"Alloc={result.final_gpu_alloc_rate:.1f}%, " + f"Scheduled={result.tasks_scheduled}, Failed={result.tasks_failed}") + + return results + + @staticmethod + def average_curves(results: List[ExperimentResult]) -> List[Tuple[float, float]]: + """Average fragmentation curves across multiple runs""" + if not results: + return [] + + # Get all x-values + all_x = set() + for r in results: + for x, _ in r.fragmentation_curve: + all_x.add(x) + + # Average y-values for each x + avg_curve = [] + for x in sorted(all_x): + y_values = [] + for r in results: + for rx, ry in r.fragmentation_curve: + if rx == x: + y_values.append(ry) + break + if y_values: + avg_curve.append((x, sum(y_values) / len(y_values))) + + return avg_curve + + +def _average_curve_by_key( + result_list: List[ExperimentResult], + curve_key: str, +) -> List[Tuple[float, float]]: + """Average one curve type across runs by x-value.""" + all_x = set() + for r in result_list: + curve = getattr(r, curve_key) + for x, _ in curve: + all_x.add(x) + + avg_curve = [] + for x in sorted(all_x): + y_values = [] + for r in result_list: + curve = getattr(r, curve_key) + for rx, ry in curve: + if rx == x: + y_values.append(ry) + break + if y_values: + avg_curve.append((x, sum(y_values) / len(y_values))) + return avg_curve + + +def plot_figure7(results: Dict[str, List[ExperimentResult]], output_path: str = None): + """ + Plot Figure 7 as one image with two sub-panels: + (a) Fragmentation rate + (b) Fragmented GPUs / total resources + """ + try: + import matplotlib + import matplotlib.pyplot as plt + except ImportError: + print("matplotlib not installed. Skipping plot.") + return + + matplotlib.rcdefaults() + matplotlib.rcParams['pdf.fonttype'] = 42 + matplotlib.rcParams.update({"font.size": 16}) + matplotlib.rcParams['lines.linewidth'] = 3 + matplotlib.rcParams['savefig.bbox'] = None + matplotlib.rcParams['savefig.pad_inches'] = 0.0 + + # Fixed canvas: 833x670. + fig, axes = plt.subplots(2, 1, figsize=(8.33, 6.00), dpi=100) + + styles = { + 'Random': {'color': 'brown', 'linestyle': '-.'}, + 'DotProd': {'color': 'purple', 'linestyle': '--'}, + 'Clustering': {'color': 'red', 'linestyle': '--'}, + 'Packing': {'color': 'darkgreen', 'linestyle': ':'}, + 'BestFit': {'color': 'orange', 'linestyle': '--'}, + 'BestFit-PN': {'color': '#fdbf6f', 'linestyle': '--'}, + 'FGD': {'color': 'blue', 'linestyle': '-'}, + } + order = ['Random', 'DotProd', 'Clustering', 'Packing', 'BestFit', 'BestFit-PN', 'FGD'] + + # --- 7(a): Frag Rate --- + ax = axes[0] + for name in [n for n in order if n in results]: + avg_curve = _average_curve_by_key(results[name], 'fragmentation_curve') + if not avg_curve: + continue + x_vals = [p[0] for p in avg_curve] + y_vals = [p[1] for p in avg_curve] + if x_vals and x_vals[0] > 0: + x_vals = [0.0] + x_vals + y_vals = [y_vals[0]] + y_vals + style = styles.get(name, {'color': 'black', 'linestyle': '-'}) + ax.plot(x_vals, y_vals, label=name, color=style['color'], linestyle=style['linestyle']) + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)', fontsize=14) + ax.set_ylabel('Frag Rate (%)', fontsize=14) + ax.set_xlim(0, 120) + ax.set_xticks([0, 20, 40, 60, 80, 100, 120]) + ax.set_ylim(0, 105) + ax.set_yticks([0, 25, 50, 75, 100]) + ax.grid(linestyle='-.', alpha=0.65) + ax.tick_params(axis='both', labelsize=12) + ax.legend(loc='upper left', bbox_to_anchor=(1.02, 1.03), fontsize=12, frameon=False) + + # --- 7(b): Frag / Total --- + ax = axes[1] + for name in [n for n in order if n in results]: + avg_curve = _average_curve_by_key(results[name], 'frag_total_curve') + if not avg_curve: + continue + x_vals = [p[0] for p in avg_curve] + y_vals = [p[1] for p in avg_curve] + if x_vals and x_vals[0] > 0: + x_vals = [0.0] + x_vals + y_vals = [y_vals[0]] + y_vals + style = styles.get(name, {'color': 'black', 'linestyle': '-'}) + ax.plot(x_vals, y_vals, label=name, color=style['color'], linestyle=style['linestyle']) + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)', fontsize=14) + ax.set_ylabel('Frag / Total (%)', fontsize=14) + ax.set_xlim(0, 120) + ax.set_xticks([0, 20, 40, 60, 80, 100, 120]) + ax.set_ylim(0, 20) + ax.set_yticks([0, 5, 10, 15, 20]) + ax.grid(linestyle='-.', alpha=0.65) + ax.tick_params(axis='both', labelsize=12) + ax.legend(loc='upper left', bbox_to_anchor=(1.02, 1.03), fontsize=12, frameon=False) + + fig.subplots_adjust(left=0.10, right=0.77, top=0.97, bottom=0.20, hspace=0.72) + + # Captions centered to full image width. + captions = [ + "(a) Fragmentation rate grows to 100% as more resources are allocated.", + "(b) Percentage of fragmented GPUs to total resources under our measure.", + ] + p0 = axes[0].get_position() + p1 = axes[1].get_position() + fig.text(0.5, p0.y0 - 0.11, captions[0], ha='center', va='top', fontsize=13, family='serif') + fig.text(0.5, p1.y0 - 0.11, captions[1], ha='center', va='top', fontsize=13, family='serif') + + if output_path: + plt.savefig(output_path, dpi=100, bbox_inches=None, pad_inches=0.0) + print(f"Plot saved to {output_path}") + + plt.show() + + +def save_results_to_csv(results: Dict[str, List[ExperimentResult]], output_path: str): + """ + Save experiment results to CSV file. + + CSV format: scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run + """ + import csv + + with open(output_path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow([ + 'scheduler', + 'arrived_workload_pct', + 'frag_rate', + 'frag_total_pct', + 'run', + ]) + + for scheduler_name, result_list in results.items(): + for run_idx, result in enumerate(result_list): + # Curves are sampled at the same x-values. + by_x_total = {x: y for x, y in result.frag_total_curve} + for arrived_pct, frag_rate in result.fragmentation_curve: + frag_total = by_x_total.get(arrived_pct, '') + writer.writerow([ + scheduler_name, + arrived_pct, + frag_rate, + frag_total, + run_idx, + ]) + + print(f"Results saved to {output_path}") + + +def load_results_from_csv(csv_path: str) -> Dict[str, List[ExperimentResult]]: + """ + Load experiment results from CSV file. + + Returns: + Dict mapping scheduler name to list of ExperimentResult + """ + import csv + from collections import defaultdict + + # Temporary storage: + # scheduler -> run -> {'frag_rate': [(x, y)], 'frag_total': [(x, y)]} + data = defaultdict(lambda: defaultdict(lambda: { + 'frag_rate': [], + 'frag_total': [], + })) + + with open(csv_path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + scheduler = row['scheduler'] + run = int(row['run']) + x = float(row['arrived_workload_pct']) + y = float(row['frag_rate']) + data[scheduler][run]['frag_rate'].append((x, y)) + + # Backward compatibility: older CSVs may not have frag_total_pct. + frag_total_raw = row.get('frag_total_pct', '') + if frag_total_raw != '': + y_total = float(frag_total_raw) + data[scheduler][run]['frag_total'].append((x, y_total)) + + # Convert to ExperimentResult objects + results = {} + for scheduler, runs in data.items(): + results[scheduler] = [] + for run_idx in sorted(runs.keys()): + result = ExperimentResult(scheduler_name=scheduler) + result.fragmentation_curve = sorted( + runs[run_idx]['frag_rate'], key=lambda p: p[0]) + result.frag_total_curve = sorted( + runs[run_idx]['frag_total'], key=lambda p: p[0]) + results[scheduler].append(result) + + return results + + +def format_summary(results: Dict[str, List[ExperimentResult]]) -> str: + """Format summary statistics as a string""" + lines = [] + lines.append("=" * 60) + lines.append("EXPERIMENT SUMMARY") + lines.append("=" * 60) + lines.append(f"\n{'Scheduler':<12} {'Avg Frag%':>10} {'Frag/Total%':>12} {'Avg Alloc%':>12} {'Scheduled':>12} {'Failed':>10}") + lines.append("-" * 60) + + for name, result_list in results.items(): + avg_frag = sum(r.final_frag_rate for r in result_list) / len(result_list) + avg_frag_total = sum(r.final_frag_total_pct for r in result_list) / len(result_list) + avg_alloc = sum(r.final_gpu_alloc_rate for r in result_list) / len(result_list) + total_scheduled = sum(r.tasks_scheduled for r in result_list) / len(result_list) + total_failed = sum(r.tasks_failed for r in result_list) / len(result_list) + + lines.append(f"{name:<12} {avg_frag:>10.1f} {avg_frag_total:>12.1f} {avg_alloc:>12.1f} {total_scheduled:>12.0f} {total_failed:>10.0f}") + + return "\n".join(lines) + + +def print_summary(results: Dict[str, List[ExperimentResult]]): + """Print summary statistics""" + print("\n" + format_summary(results)) + + +if __name__ == "__main__": + import argparse + from datetime import datetime + + parser = argparse.ArgumentParser(description="Figure 7(a)/(b) Replication Experiment") + parser.add_argument('--seed', type=int, default=42, help='Random seed (default: 42)') + parser.add_argument('--num-runs', type=int, default=3, help='Number of runs per scheduler (default: 3, paper uses 10)') + parser.add_argument('--max-workload', type=float, default=120.0, help='Max arrived workload %% (default: 120)') + parser.add_argument('--sample-interval', type=float, default=5.0, help='Fragmentation sampling interval %% (default: 5)') + parser.add_argument('--fgd-popularity-threshold', type=float, default=95.0, + help='Typical-pod popularity threshold (%) used for FGD scoring (default: 95)') + parser.add_argument('--plot-csv', type=str, default=None, + help='Plot from existing CSV file instead of running experiment') + parser.add_argument('--schedulers', type=str, default='all', + help='Comma-separated scheduler names to run (default: all). ' + 'Available: Random,BestFit,DotProd,Packing,Clustering,FGD') + args = parser.parse_args() + + # Plot-only mode + if args.plot_csv: + results = load_results_from_csv(args.plot_csv) + print(f"Loaded {len(results)} schedulers from {args.plot_csv}") + plot_dir = os.path.dirname(args.plot_csv) + plot_path = os.path.join(plot_dir, 'figure7.png') + # Figure 7(b) can be drawn only from CSVs that include frag_total_pct. + if any(r.frag_total_curve for runs in results.values() for r in runs): + plot_figure7(results, plot_path) + else: + print("INFO: CSV has no 'frag_total_pct' column; skipping Figure 7 plot.") + exit(0) + + # Run the experiment + data_dir = os.path.join(os.path.dirname(__file__), '..', 'alibaba_traces', 'cluster-trace-gpu-v2023') + + print("=" * 60) + print("Figure 7(a)/(b) Replication Experiment") + print(f" seed={args.seed}, runs={args.num_runs}, " + f"max_workload={args.max_workload}%, interval={args.sample_interval}%") + print("=" * 60) + + experiment = Figure7aExperiment( + data_dir, + seed=args.seed, + fgd_popularity_threshold=args.fgd_popularity_threshold, + ) + + # Filter schedulers + all_sched_map = {s.name: s for s in get_all_schedulers()} + if args.schedulers == 'all': + schedulers = get_all_schedulers() + else: + selected = [s.strip() for s in args.schedulers.split(',')] + schedulers = [] + for name in selected: + if name in all_sched_map: + schedulers.append(all_sched_map[name]) + else: + print(f"WARNING: Unknown scheduler '{name}'. Available: {list(all_sched_map.keys())}") + if not schedulers: + print("No valid schedulers selected. Exiting.") + exit(1) + + results = experiment.run_experiment( + schedulers=schedulers, + num_runs=args.num_runs, + max_workload_pct=args.max_workload, + sample_interval_pct=args.sample_interval + ) + + # Create result directory + result_name = f"fig7-runs{args.num_runs}-seed{args.seed}" + result_dir = os.path.join(os.path.dirname(__file__), 'result', result_name) + os.makedirs(result_dir, exist_ok=True) + + # Print summary + print_summary(results) + + # Save summary log + log_path = os.path.join(result_dir, 'experiment_summary.log') + with open(log_path, 'w') as f: + f.write(f"Experiment: Figure 7(a) Replication\n") + f.write(f"Seed: {args.seed}\n") + f.write(f"Num runs: {args.num_runs}\n") + f.write(f"Max workload: {args.max_workload}%\n") + f.write(f"Sample interval: {args.sample_interval}%\n\n") + f.write(format_summary(results) + "\n") + print(f"Summary log saved to {log_path}") + + # Save results to CSV + csv_path = os.path.join(result_dir, 'figure7_results.csv') + save_results_to_csv(results, csv_path) + + # Plot results + plot_path = os.path.join(result_dir, 'figure7.png') + plot_figure7(results, plot_path) diff --git a/standalone_fgd_replication/exp_fig9.py b/standalone_fgd_replication/exp_fig9.py new file mode 100644 index 0000000..21cec0b --- /dev/null +++ b/standalone_fgd_replication/exp_fig9.py @@ -0,0 +1,744 @@ +""" +Experiment 2: Replicates Figure 9 from Section 6.2 + +Figure 9 has 4 sub-plots: + 9(a): Unallocated GPU % vs arrived workloads (80-120% range) + 9(b): Occupied nodes vs arrived workloads (0-100% range) + 9(c): Failed tasks by GPU request category at 96% arrival (bar chart) + 9(d): Fragmentation breakdown into 3 causes (bar chart) + +Methodology: Monte-Carlo workload inflation (Section 6.1) + - Sample tasks from trace with replacement + - Submit until cumulative GPU requests reach target (120%) + - Repeat N runs, average results +""" + +import os +import random +from typing import List, Dict, Tuple +from dataclasses import dataclass, field +from collections import Counter, defaultdict + +from simulator import Task, Node, Cluster, TaskDistribution +from schedulers import ( + Scheduler, get_all_schedulers, get_all_schedulers_with_bestfit_variants, + BestFitLocalScheduler, ClusteringScheduler, FGDScheduler +) +from trace_loader import AlibabaTraceLoader + + +@dataclass +class Figure9Result: + """Results from a single Monte-Carlo run for Figure 9""" + scheduler_name: str + # 9(a): (arrived_pct, unallocated_gpu_pct) + unalloc_curve: List[Tuple[float, float]] = field(default_factory=list) + # 9(b): (arrived_pct, occupied_nodes) + occupied_curve: List[Tuple[float, int]] = field(default_factory=list) + # 9(c): failed tasks at 96% by GPU category: {category: sum_of_gpu_demand} + failed_by_category: Dict[str, float] = field(default_factory=dict) + # 9(d): fragmentation breakdown: {cause: pct} + frag_breakdown: Dict[str, float] = field(default_factory=dict) + # Summary + tasks_scheduled: int = 0 + tasks_failed: int = 0 + + +class Figure9Experiment: + """ + Replicates Figure 9: Multi-metric evaluation using Monte-Carlo workload inflation. + + Tasks are randomly sampled from the trace with replacement and submitted + until cumulative GPU requests reach max_arrival_pct% of cluster capacity. + """ + + def __init__(self, data_dir: str, fgd_popularity_threshold: float = 95): + self.data_dir = data_dir + self.fgd_popularity_threshold = fgd_popularity_threshold + self.loader = AlibabaTraceLoader(data_dir) + self.loader.load_nodes() + self.loader.load_tasks() + + self.task_distribution = self.loader.compute_task_distribution() + # Paper's experiment scripts use pod-popularity-threshold=95 by default. + # Keep a filtered distribution for FGD scoring only. + self.fgd_scoring_distribution = self.loader.compute_task_distribution( + popularity_threshold=self.fgd_popularity_threshold + ) + self.total_gpu_capacity = sum(n.num_gpus for n in self.loader.nodes) + + print(f"Loaded trace: {len(self.loader.nodes)} nodes, {self.total_gpu_capacity} GPUs") + print(f"Tasks in trace: {len(self.loader.tasks)}") + print(f"Task types (full): {len(self.task_distribution.get_task_types())}") + print(f"Task types (FGD scoring, top {self.fgd_popularity_threshold:.0f}%): " + f"{len(self.fgd_scoring_distribution.get_task_types())}") + + def create_fresh_cluster(self) -> Cluster: + """Create a fresh cluster from trace nodes""" + cluster = Cluster() + for i, orig_node in enumerate(self.loader.nodes): + node = Node( + node_id=i, + total_cpu=orig_node.total_cpu, + num_gpus=orig_node.num_gpus, + name=orig_node.name, + gpu_model=orig_node.gpu_model, + memory_mib=orig_node.memory_mib + ) + cluster.add_node(node) + cluster.set_task_distribution(self.task_distribution) + return cluster + + @staticmethod + def _gpu_category(gpu_demand: float) -> str: + """Categorize GPU demand for Figure 9(c)""" + if gpu_demand < 1: + return "<1" + elif gpu_demand == 1: + return "1" + elif gpu_demand == 2: + return "2" + else: + return "8" + + @staticmethod + def _compute_frag_breakdown(cluster: Cluster) -> Dict[str, float]: + """ + Decompose fragmentation into 3 causes for Figure 9(d). + Uses per-task-type statistical measure from Section 3.2, Figure 4b. + + For each node n and task type m (weighted by popularity p_m): + - Deficient (Q-I/Q-II): D_m^GPU > R_n^GPU — insufficient GPU capacity + - Stranded (Q-IV): D_m^GPU <= R_n^GPU but D_m^CPU > R_n^CPU — GPU stranded by CPU shortage + - Non-GPU (Case 3): D_m^GPU = 0 — all unallocated GPUs wasted + - Q-III (node can run task, individual GPUs too small): counted as Deficient + """ + if cluster.task_distribution is None: + return {"deficient": 0, "stranded": 0, "non_gpu": 0} + + task_types = cluster.task_distribution.get_task_types() + + deficient = 0.0 + stranded = 0.0 + non_gpu = 0.0 + + for node in cluster.nodes: + if node.total_unallocated_gpu == 0: + continue + + for (cpu_demand, gpu_demand), popularity in task_types: + task = Task(task_id=-1, cpu_demand=cpu_demand, gpu_demand=gpu_demand) + frag = node.get_fragmentation_for_task(task) + + if frag == 0: + continue + + weighted_frag = popularity * frag + + if gpu_demand == 0: + # Case 3: Non-GPU task + non_gpu += weighted_frag + elif gpu_demand > node.scalar_gpu_capacity: + # Q-I/Q-II: Insufficient GPU → Deficient + deficient += weighted_frag + elif cpu_demand > node.remaining_cpu: + # Q-IV: Has GPU but not enough CPU → Stranded + stranded += weighted_frag + else: + # Q-III: Can run task but individual GPUs too small → Deficient + deficient += weighted_frag + + total = deficient + stranded + non_gpu + if total == 0: + return {"deficient": 0, "stranded": 0, "non_gpu": 0} + + return { + "deficient": deficient / total * 100, + "stranded": stranded / total * 100, + "non_gpu": non_gpu / total * 100, + } + + @staticmethod + def _count_occupied_nodes(cluster: Cluster) -> int: + """Count nodes with at least one task (any allocation)""" + count = 0 + for node in cluster.nodes: + if node.allocated_cpu > 0 or any(g < 1.0 for g in node.gpu_remaining): + count += 1 + return count + + def run_single( + self, + scheduler: Scheduler, + seed: int = 42, + sample_interval_pct: float = 2.0, + max_arrival_pct: float = 120.0, + snapshot_pct: float = 96.0, + show_progress: bool = True + ) -> Figure9Result: + """ + Run a single Monte-Carlo experiment. + + Args: + seed: Random seed for sampling + sample_interval_pct: How often to record metrics + max_arrival_pct: Stop when cumulative GPU requests reach this % of capacity + snapshot_pct: Record failed task breakdown at this arrival % + """ + from tqdm import tqdm + + rng = random.Random(seed) + cluster = self.create_fresh_cluster() + result = Figure9Result(scheduler_name=scheduler.name) + + if isinstance(scheduler, ClusteringScheduler): + scheduler.reset() + + # Use filtered distribution for FGD scoring (paper scripts default: 95% threshold). + # Cluster distribution (full) is kept for fragmentation metric computation. + if isinstance(scheduler, FGDScheduler): + scheduler.scheduling_task_types = self.fgd_scoring_distribution.get_task_types() + + cumulative_gpu_demand = 0.0 + next_sample_pct = sample_interval_pct + max_gpu_demand = self.total_gpu_capacity * max_arrival_pct / 100.0 + task_pool = self.loader.tasks + + # Track ALL failed tasks up to snapshot point + all_failed_tasks: List[Task] = [] + snapshot_taken = False + + task_count = 0 + estimated_tasks = int(len(task_pool) * max_arrival_pct / 100.0) + + pbar = tqdm( + total=estimated_tasks, + desc=f"{scheduler.name:12} s={seed}", + unit="task", + disable=not show_progress, + ncols=90 + ) + + while cumulative_gpu_demand < max_gpu_demand: + # Sample a random task from the trace + orig_task = rng.choice(task_pool) + task = Task( + task_id=task_count, + cpu_demand=orig_task.cpu_demand, + gpu_demand=orig_task.gpu_demand + ) + task_count += 1 + cumulative_gpu_demand += task.gpu_demand + arrived_pct = (cumulative_gpu_demand / self.total_gpu_capacity) * 100 + + # Try to schedule + if scheduler.schedule(task, cluster): + result.tasks_scheduled += 1 + else: + result.tasks_failed += 1 + if not snapshot_taken: + all_failed_tasks.append(task) + + # Take snapshot at snapshot_pct (all failed tasks up to this point) + if not snapshot_taken and arrived_pct >= snapshot_pct: + snapshot_taken = True + cat_sums: Dict[str, float] = defaultdict(float) + for t in all_failed_tasks: + cat = self._gpu_category(t.gpu_demand) + cat_sums[cat] += t.gpu_demand + result.failed_by_category = dict(cat_sums) + + # Record metrics at intervals + if arrived_pct >= next_sample_pct: + unalloc_pct = (cluster.total_unallocated_gpu / self.total_gpu_capacity) * 100 + result.unalloc_curve.append((next_sample_pct, unalloc_pct)) + + occupied = self._count_occupied_nodes(cluster) + result.occupied_curve.append((next_sample_pct, occupied)) + + next_sample_pct += sample_interval_pct + + pbar.update(1) + + pbar.close() + + # 9(d): Fragmentation breakdown at end + result.frag_breakdown = self._compute_frag_breakdown(cluster) + + return result + + def run_experiment( + self, + schedulers: List[Scheduler] = None, + num_runs: int = 10, + seed: int = 42, + sample_interval_pct: float = 2.0, + max_arrival_pct: float = 120.0, + show_progress: bool = True + ) -> Dict[str, List[Figure9Result]]: + """Run Monte-Carlo experiment for multiple schedulers, multiple runs.""" + if schedulers is None: + schedulers = get_all_schedulers() + + results: Dict[str, List[Figure9Result]] = {s.name: [] for s in schedulers} + + for scheduler in schedulers: + for run_idx in range(num_runs): + run_seed = seed + run_idx + result = self.run_single( + scheduler, + seed=run_seed, + sample_interval_pct=sample_interval_pct, + max_arrival_pct=max_arrival_pct, + show_progress=show_progress + ) + results[scheduler.name].append(result) + + # Print average for this scheduler + avg_sched = sum(r.tasks_scheduled for r in results[scheduler.name]) / num_runs + avg_fail = sum(r.tasks_failed for r in results[scheduler.name]) / num_runs + print(f" {scheduler.name:12}: Avg Scheduled={avg_sched:.0f}, Avg Failed={avg_fail:.0f}") + + return results + + +def plot_figure9(results: Dict[str, List[Figure9Result]], total_nodes: int, + total_gpu: int, output_dir: str = None): + """Plot all 4 sub-figures of Figure 9.""" + try: + import matplotlib.pyplot as plt + import numpy as np + except ImportError: + print("matplotlib/numpy not installed. Skipping plot.") + return + + styles = { + 'Random': {'color': 'brown', 'linestyle': '-.'}, + 'DotProd': {'color': 'purple', 'linestyle': '--'}, + 'Clustering': {'color': 'red', 'linestyle': '--'}, + 'Packing': {'color': 'darkgreen', 'linestyle': ':'}, + 'BestFit': {'color': 'orange', 'linestyle': '--'}, + 'BestFit-PN': {'color': '#fdbf6f', 'linestyle': '--'}, + 'FGD': {'color': 'blue', 'linestyle': '-'}, + } + + # Fixed output size: 590x900 pixels. + fig, axes = plt.subplots(4, 1, figsize=(5.9, 9), dpi=100) + + # --- 9(a): Unallocated GPU % --- + ax = axes[0] + # Ideal line: max(0, 100 - arrived_pct), include pre-80 segment. + ideal_x = list(range(70, 121)) + ideal_y = [max(0, 100 - x) for x in ideal_x] + ax.plot(ideal_x, ideal_y, color='gray', linestyle=':', linewidth=1.5, label='Ideal') + + for name, result_list in results.items(): + # Average curves across runs + all_curves = [r.unalloc_curve for r in result_list] + avg = _average_curves(all_curves) + if avg: + x_vals = [p[0] for p in avg] + y_vals = [p[1] for p in avg] + # Keep pre-80 data so visible line starts around x~76 like paper. + filtered = [(x, y) for x, y in zip(x_vals, y_vals) if 70 <= x <= 120] + if filtered: + style = styles.get(name, {'color': 'black', 'linestyle': '-'}) + ax.plot([p[0] for p in filtered], [p[1] for p in filtered], + label=name, color=style['color'], linestyle=style['linestyle'], + linewidth=2) + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)') + ax.set_ylabel('Unalloc. GPU (%)') + ax.legend(fontsize=9, loc='center left', bbox_to_anchor=(1.02, 0.5), frameon=False) + ax.set_xlim(75, 120) + ax.set_xticks([80, 90, 100, 110, 120]) + ax.set_ylim(0, 25) + ax.set_yticks([0, 5, 10, 15, 20, 25]) + ax.grid(True, linestyle='--', alpha=0.35) + + # --- 9(b): Occupied nodes --- + ax = axes[1] + for name, result_list in results.items(): + all_curves = [r.occupied_curve for r in result_list] + avg = _average_curves(all_curves) + if avg: + x_vals = [p[0] for p in avg] + y_vals = [p[1] for p in avg] + # Keep all data (including >100%) and let xlim clip at panel boundary. + filtered = [(x, y) for x, y in zip(x_vals, y_vals) if x >= 0] + if filtered: + # Start from true origin for occupied-node curves. + if filtered[0][0] > 0: + filtered = [(0.0, 0.0)] + filtered + style = styles.get(name, {'color': 'black', 'linestyle': '-'}) + ax.plot([p[0] for p in filtered], [p[1] for p in filtered], + label=name, color=style['color'], linestyle=style['linestyle'], + linewidth=2) + + ax.set_xlabel('Arrived workloads (in % of cluster GPU capacity)') + ax.set_ylabel('Occupied nodes') + ax.legend(fontsize=9, loc='center left', bbox_to_anchor=(1.02, 0.5), frameon=False) + ax.set_xlim(0, 105) + ax.set_xticks([0, 20, 40, 60, 80, 100]) + ax.set_ylim(0, 1250) + ax.set_yticks([0, 250, 500, 750, 1000, 1250]) + ax.grid(True, linestyle='--', alpha=0.35) + + # Fixed scheduler order for bar charts (9c, 9d) + bar_order = ['FGD', 'BestFit', 'BestFit-PN', 'Packing', 'Clustering', 'DotProd', 'Random'] + scheduler_names = [n for n in bar_order if n in results] + x_pos = np.arange(len(scheduler_names)) + + # --- 9(c): Failed tasks by GPU category (stacked bar) --- + ax = axes[2] + # Bottom -> top order requested: <1, 1, 2, 8 + categories = ['<1', '1', '2', '8'] + cat_colors = {'<1': 'orange', '1': 'green', '2': 'red', '8': '#8c564b'} + + bottoms = np.zeros(len(scheduler_names)) + cat_handles = {} + for cat in categories: + values = [] + for name in scheduler_names: + avg_val = sum(r.failed_by_category.get(cat, 0) for r in results[name]) / len(results[name]) + values.append(avg_val) + cat_handles[cat] = ax.bar(x_pos, values, bottom=bottoms, label=cat, color=cat_colors[cat], + edgecolor='0', linewidth=0.3) + bottoms += np.array(values) + + ax.set_xticks(x_pos) + ax.set_xticklabels(scheduler_names, rotation=0, fontsize=10) + ax.set_ylabel('Sum of Pending Task GPUs') + ax.set_title('When arrived workloads equals 96% GPU capacity', fontsize=11) + ax.set_ylim(0, 700) + ax.set_yticks([0, 100, 200, 300, 400, 500, 600, 700]) + legend_order_top_to_bottom = ['8', '2', '1', '<1'] + ax.legend( + handles=[cat_handles[c][0] for c in legend_order_top_to_bottom], + labels=legend_order_top_to_bottom, + title='Task GPU Req', + fontsize=7, + title_fontsize=8, + loc='upper left', + frameon=True, + borderpad=0.5, + handlelength=1.5, + handletextpad=0.5, + labelspacing=0.35, + ) + ax.grid(True, linestyle='--', alpha=0.35, axis='y') + + # --- 9(d): Fragmentation breakdown (stacked bar) --- + ax = axes[3] + causes = ['deficient', 'stranded', 'non_gpu'] + cause_colors = {'deficient': 'blue', 'stranded': 'orange', 'non_gpu': 'green'} + cause_labels = {'deficient': 'Deficient', 'stranded': 'Stranded', 'non_gpu': 'Non-GPU'} + + bottoms = np.zeros(len(scheduler_names)) + for cause in causes: + values = [] + for name in scheduler_names: + avg_val = sum(r.frag_breakdown.get(cause, 0) for r in results[name]) / len(results[name]) + values.append(avg_val) + ax.bar(x_pos, values, bottom=bottoms, label=cause_labels[cause], + color=cause_colors[cause], edgecolor='0', linewidth=0.3) + bottoms += np.array(values) + + ax.set_xticks(x_pos) + ax.set_xticklabels(scheduler_names, rotation=0, fontsize=10) + ax.set_ylabel('Fragmented GPUs (%)') + ax.legend(fontsize=9, loc='lower left', frameon=True) + ax.set_ylim(0, 100) + ax.set_yticks([0, 25, 50, 75, 100]) + ax.grid(True, linestyle='--', alpha=0.35, axis='y') + + # Base spacing first. + fig.subplots_adjust(left=0.10, right=0.98, top=0.98, bottom=0.07, hspace=1.05) + + # Make 9(c)/(d) full-width; keep 9(a)/(b) slightly narrower for legends. + # 9(a)/(b) chart width is still extended to reduce right whitespace. + left = 0.10 + right_line = 0.82 + right_bar = 0.98 + for i in [0, 1]: + p = axes[i].get_position() + axes[i].set_position([left, p.y0, right_line - left, p.height]) + for i in [2, 3]: + p = axes[i].get_position() + axes[i].set_position([left, p.y0, right_bar - left, p.height]) + + # Add centered captions under each panel (centered to full image width). + captions = [ + "(a) The percentage of unallocated GPUs given arriving workloads.", + "(b) The number of GPU nodes occupied during the scheduling.", + "(c) GPU requests of failed tasks when the cluster is almost full\n(i.e., cumulative GPU requests reach 96% of the cluster capacity).", + "(d) The breakdown of GPU fragmentation into three causes.", + ] + # Increase spacing between x-axis labels and captions for all panels. + caption_offsets = [0.060, 0.060, 0.050, 0.045] + for i, cap in enumerate(captions): + p = axes[i].get_position() + fig.text(0.5, p.y0 - caption_offsets[i], cap, ha='center', va='top', fontsize=9) + + if output_dir: + path = os.path.join(output_dir, 'figure9.png') + plt.savefig(path, dpi=150, bbox_inches='tight') + print(f"Plot saved to {path}") + + plt.show() + + +def _average_curves(curves: List[List[Tuple[float, float]]]) -> List[Tuple[float, float]]: + """Average multiple curves by x-value.""" + if not curves: + return [] + by_x: Dict[float, List[float]] = defaultdict(list) + for curve in curves: + for x, y in curve: + by_x[x].append(y) + return sorted([(x, sum(ys) / len(ys)) for x, ys in by_x.items()]) + + +def save_results_to_csv(results: Dict[str, List[Figure9Result]], output_dir: str): + """Save all Figure 9 data to CSV files.""" + import csv + + # 9(a): Unallocated GPU curves + path = os.path.join(output_dir, 'figure9a_unalloc.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'arrived_pct', 'unalloc_gpu_pct', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for x, y in r.unalloc_curve: + writer.writerow([name, x, y, run_idx]) + + # 9(b): Occupied nodes curves + path = os.path.join(output_dir, 'figure9b_occupied.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'arrived_pct', 'occupied_nodes', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for x, y in r.occupied_curve: + writer.writerow([name, x, y, run_idx]) + + # 9(c): Failed task breakdown + path = os.path.join(output_dir, 'figure9c_failed.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'gpu_category', 'sum_gpu_demand', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for cat, val in r.failed_by_category.items(): + writer.writerow([name, cat, val, run_idx]) + + # 9(d): Fragmentation breakdown + path = os.path.join(output_dir, 'figure9d_breakdown.csv') + with open(path, 'w', newline='') as f: + writer = csv.writer(f) + writer.writerow(['scheduler', 'cause', 'pct', 'run']) + for name, result_list in results.items(): + for run_idx, r in enumerate(result_list): + for cause, pct in r.frag_breakdown.items(): + writer.writerow([name, cause, pct, run_idx]) + + print(f"CSV files saved to {output_dir}") + + +def load_results_from_csv(csv_dir: str) -> Dict[str, List[Figure9Result]]: + """Load Figure 9 results from CSV files in a directory.""" + import csv + from collections import defaultdict + + results: Dict[str, List[Figure9Result]] = {} + + # Helper to load curve data + def load_curve_csv(filename, x_col, y_col): + path = os.path.join(csv_dir, filename) + if not os.path.exists(path): + return {} + data = defaultdict(lambda: defaultdict(list)) + with open(path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + name = row['scheduler'] + run = int(row['run']) + data[name][run].append((float(row[x_col]), float(row[y_col]))) + return data + + # Helper to load category data + def load_cat_csv(filename, cat_col, val_col): + path = os.path.join(csv_dir, filename) + if not os.path.exists(path): + return {} + data = defaultdict(lambda: defaultdict(dict)) + with open(path, 'r') as f: + reader = csv.DictReader(f) + for row in reader: + name = row['scheduler'] + run = int(row['run']) + data[name][run][row[cat_col]] = float(row[val_col]) + return data + + # Load all sub-figure data + unalloc = load_curve_csv('figure9a_unalloc.csv', 'arrived_pct', 'unalloc_gpu_pct') + occupied = load_curve_csv('figure9b_occupied.csv', 'arrived_pct', 'occupied_nodes') + failed = load_cat_csv('figure9c_failed.csv', 'gpu_category', 'sum_gpu_demand') + breakdown = load_cat_csv('figure9d_breakdown.csv', 'cause', 'pct') + + # Merge into Figure9Result objects + all_names = set(unalloc) | set(occupied) | set(failed) | set(breakdown) + for name in all_names: + # Determine number of runs + runs_set = set() + for d in [unalloc, occupied, failed, breakdown]: + if name in d: + runs_set |= set(d[name].keys()) + results[name] = [] + for run_idx in sorted(runs_set): + r = Figure9Result(scheduler_name=name) + if name in unalloc and run_idx in unalloc[name]: + r.unalloc_curve = sorted(unalloc[name][run_idx]) + if name in occupied and run_idx in occupied[name]: + r.occupied_curve = sorted(occupied[name][run_idx]) + if name in failed and run_idx in failed[name]: + r.failed_by_category = failed[name][run_idx] + if name in breakdown and run_idx in breakdown[name]: + r.frag_breakdown = breakdown[name][run_idx] + results[name].append(r) + + return results + + +def format_summary(results: Dict[str, List[Figure9Result]]) -> str: + """Format summary statistics""" + lines = [] + lines.append("=" * 70) + lines.append("EXPERIMENT SUMMARY (Figure 9)") + lines.append("=" * 70) + lines.append(f"\n{'Scheduler':<12} {'Scheduled':>10} {'Failed':>8} " + f"{'Unalloc%':>9} {'Occupied':>9} {'Deficient':>10} {'Stranded':>9} {'Non-GPU':>8}") + lines.append("-" * 80) + + for name, result_list in results.items(): + n = len(result_list) + avg_sched = sum(r.tasks_scheduled for r in result_list) / n + avg_fail = sum(r.tasks_failed for r in result_list) / n + + # Final unallocated % + avg_unalloc = 0 + for r in result_list: + if r.unalloc_curve: + avg_unalloc += r.unalloc_curve[-1][1] + avg_unalloc /= n + + # Final occupied nodes + avg_occupied = 0 + for r in result_list: + if r.occupied_curve: + avg_occupied += r.occupied_curve[-1][1] + avg_occupied /= n + + # Frag breakdown + avg_def = sum(r.frag_breakdown.get('deficient', 0) for r in result_list) / n + avg_str = sum(r.frag_breakdown.get('stranded', 0) for r in result_list) / n + avg_ng = sum(r.frag_breakdown.get('non_gpu', 0) for r in result_list) / n + + lines.append(f"{name:<12} {avg_sched:>10.0f} {avg_fail:>8.0f} " + f"{avg_unalloc:>9.1f} {avg_occupied:>9.0f} " + f"{avg_def:>10.1f} {avg_str:>9.1f} {avg_ng:>8.1f}") + + return "\n".join(lines) + + +if __name__ == "__main__": + import argparse + + parser = argparse.ArgumentParser(description="Figure 9 Replication - Monte-Carlo") + parser.add_argument('--num-runs', type=int, default=10, help='Number of Monte-Carlo runs (default: 10)') + parser.add_argument('--seed', type=int, default=42, help='Base random seed (default: 42)') + parser.add_argument('--sample-interval', type=float, default=2.0, help='Sampling interval %% (default: 2)') + parser.add_argument('--max-arrival', type=float, default=120.0, help='Max arrival %% (default: 120)') + parser.add_argument('--fgd-popularity-threshold', type=float, default=95.0, + help='Typical-pod popularity threshold (%) used for FGD scoring (default: 95)') + parser.add_argument('--plot-csv', type=str, default=None, + help='Plot from existing CSV directory instead of running experiment') + parser.add_argument('--schedulers', type=str, default='all', + help='Comma-separated scheduler names to run (default: all). ' + 'Available: Random,BestFit,BestFit-PN,DotProd,Packing,Clustering,FGD') + args = parser.parse_args() + + # Plot-only mode + if args.plot_csv: + csv_dir = args.plot_csv + results = load_results_from_csv(csv_dir) + print(f"Loaded {len(results)} schedulers from {csv_dir}") + plot_figure9(results, total_nodes=0, total_gpu=0, output_dir=csv_dir) + exit(0) + + data_dir = os.path.join(os.path.dirname(__file__), '..', 'alibaba_traces', 'cluster-trace-gpu-v2023') + + print("=" * 60) + print("Figure 9 Replication - Monte-Carlo Workload Inflation") + print(f" runs={args.num_runs}, seed={args.seed}") + print(f" interval={args.sample_interval}%, max_arrival={args.max_arrival}%") + print("=" * 60) + + experiment = Figure9Experiment( + data_dir, + fgd_popularity_threshold=args.fgd_popularity_threshold, + ) + + all_sched_map = {s.name: s for s in get_all_schedulers_with_bestfit_variants()} + if args.schedulers == 'all': + schedulers = get_all_schedulers_with_bestfit_variants() + else: + selected = [s.strip() for s in args.schedulers.split(',')] + schedulers = [] + for name in selected: + if name in all_sched_map: + schedulers.append(all_sched_map[name]) + else: + print(f"WARNING: Unknown scheduler '{name}'. Available: {list(all_sched_map.keys())}") + if not schedulers: + print("No valid schedulers selected. Exiting.") + exit(1) + + results = experiment.run_experiment( + schedulers=schedulers, + num_runs=args.num_runs, + seed=args.seed, + sample_interval_pct=args.sample_interval, + max_arrival_pct=args.max_arrival + ) + + # Create result directory + result_name = f"fig9-runs{args.num_runs}-seed{args.seed}" + result_dir = os.path.join(os.path.dirname(__file__), 'result', result_name) + os.makedirs(result_dir, exist_ok=True) + + # Print & save summary + summary = format_summary(results) + print("\n" + summary) + + log_path = os.path.join(result_dir, 'experiment_summary.log') + with open(log_path, 'w') as f: + f.write("Experiment: Figure 9 Replication - Monte-Carlo\n") + f.write(f"Result: {result_name}\n") + f.write(f"Runs: {args.num_runs}\n") + f.write(f"Base seed: {args.seed}\n") + f.write(f"Sample interval: {args.sample_interval}%\n") + f.write(f"Max arrival: {args.max_arrival}%\n") + f.write(f"Nodes: {len(experiment.loader.nodes)}\n") + f.write(f"GPUs: {experiment.total_gpu_capacity}\n") + f.write(f"Task pool: {len(experiment.loader.tasks)}\n\n") + f.write(summary + "\n") + print(f"Summary log saved to {log_path}") + + # Save CSV data + save_results_to_csv(results, result_dir) + + # Plot + plot_figure9(results, len(experiment.loader.nodes), + experiment.total_gpu_capacity, result_dir) diff --git a/standalone_fgd_replication/plot_results.py b/standalone_fgd_replication/plot_results.py new file mode 100644 index 0000000..86ad215 --- /dev/null +++ b/standalone_fgd_replication/plot_results.py @@ -0,0 +1,45 @@ +""" +Plot Figure 7(a) from CSV results file. + +Usage: + python plot_results.py [output_path] + +Example: + python plot_results.py figure7a_results.csv figure7a.png +""" + +import sys +import os + +from experiment import load_results_from_csv, plot_figure7a + + +def main(): + if len(sys.argv) < 2: + print("Usage: python plot_results.py [output_path]") + print("Example: python plot_results.py figure7a_results.csv figure7a.png") + sys.exit(1) + + csv_path = sys.argv[1] + + if not os.path.exists(csv_path): + print(f"Error: CSV file not found: {csv_path}") + sys.exit(1) + + # Optional output path + output_path = sys.argv[2] if len(sys.argv) > 2 else None + + print(f"Loading results from {csv_path}...") + results = load_results_from_csv(csv_path) + + print(f"Loaded {len(results)} schedulers:") + for name, result_list in results.items(): + num_points = sum(len(r.fragmentation_curve) for r in result_list) + print(f" {name}: {len(result_list)} runs, {num_points} data points") + + print("\nPlotting...") + plot_figure7a(results, output_path) + + +if __name__ == "__main__": + main() diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-ascending-90/experiment_summary.log new file mode 100644 index 0000000..2b56ec4 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-ascending-90/experiment_summary.log @@ -0,0 +1,23 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-ascending-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: ascending +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 15 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 88.4 77.8 6811 1341 14.9 +Clustering 98.9 81.2 7002 1150 12.9 +FGD-Full 76.7 57.6 5673 2479 84.5 +FGD-2000 70.2 52.8 5402 2750 60.2 diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure7.png b/standalone_fgd_replication/result/dist-shift-ascending-90/figure7.png new file mode 100644 index 0000000..40d87db Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-ascending-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-ascending-90/figure7_results.csv new file mode 100644 index 0000000..7eb4fe0 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-ascending-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.872568349048816,13.872568349048816,0 +Random,2.0,19.480454422448783,19.090152941804323,0 +Random,4.0,20.785771606289863,19.95374971245651,0 +Random,6.0,21.63509332328417,20.335526672623118,0 +Random,8.0,22.56960350037882,20.763353359215614,0 +Random,10.0,23.40702772499491,21.064536251247617,0 +Random,12.0,24.550740690487565,21.604433656387858,0 +Random,14.0,25.624303036522463,22.033986171398105,0 +Random,16.0,26.59711121600174,22.339588209657144,0 +Random,18.0,27.248794353337075,22.341735390822983,0 +Random,20.0,27.95703551374468,22.363044856976405,0 +Random,22.0,28.711095836521338,22.39174639552436,0 +Random,24.0,29.48958016540252,22.4088316739372,0 +Random,26.0,30.39516678797392,22.48880430780871,0 +Random,28.0,31.467581443886335,22.652632220788888,0 +Random,30.0,32.40530019021136,22.679275784268146,0 +Random,32.0,33.199315554001075,22.574590576278418,0 +Random,34.0,33.75432992970905,22.274138598719638,0 +Random,36.0,34.35196340206969,21.984768189716217,0 +Random,38.0,35.07506599144675,21.74317490516515,0 +Random,40.0,35.78958905441098,21.46739310048832,0 +Random,42.0,36.55155404449572,21.196913303358492,0 +Random,44.0,37.65884137985486,21.082794049194707,0 +Random,46.0,38.760071704560964,20.92782119296196,0 +Random,48.0,39.909789137993144,20.747132608220603,0 +Random,50.0,41.25568952276998,20.625645239995784,0 +Random,52.0,42.779764423730825,20.528508956274706,0 +Random,54.0,44.51143282273243,20.47351882562571,0 +Random,56.0,46.417433412464504,20.418061343972262,0 +Random,58.0,48.38836169150405,20.321908005928947,0 +Random,60.0,50.64521868037642,20.252687235575447,0 +Random,62.0,53.31170842111369,20.257880743917827,0 +Random,64.0,56.069694869666584,20.17990866359502,0 +Random,66.0,59.28847389095713,20.147755424611443,0 +Random,68.0,62.50536822917595,19.996830262335695,0 +Random,70.0,66.44924837580959,19.92414641188312,0 +Random,72.0,70.90387396014549,19.848548473790935,0 +Random,74.0,75.94908223040004,19.735693626673434,0 +Random,76.0,82.1790968088321,19.71889399525245,0 +Random,78.0,88.15965593243182,19.634206649106805,0 +Random,80.0,88.15965593243182,19.634206649106805,0 +Random,82.0,88.15965593243182,19.634206649106805,0 +Random,84.0,88.15965593243182,19.634206649106805,0 +Random,86.0,88.15965593243182,19.634206649106805,0 +Random,88.0,88.15965593243182,19.634206649106805,0 +Random,90.0,88.15965593243182,19.634206649106805,0 +Random,92.0,88.15965593243182,19.634206649106805,0 +Random,94.0,88.15965593243182,19.634206649106805,0 +Random,96.0,88.15965593243182,19.634206649106805,0 +Random,98.0,88.15965593243182,19.634206649106805,0 +Random,100.0,88.15965593243182,19.634206649106805,0 +Random,102.0,88.42579094541699,19.59919077077031,0 +Random,104.0,88.42579094541699,19.59919077077031,0 +Random,106.0,88.42579094541699,19.59919077077031,0 +Random,108.0,88.42579094541699,19.59919077077031,0 +Clustering,0.0,13.872568349048816,13.872568349048816,0 +Clustering,2.0,21.950620145544264,21.51082755353994,0 +Clustering,4.0,22.295863356744288,21.403394854438844,0 +Clustering,6.0,22.603052472858575,21.245342905446808,0 +Clustering,8.0,23.98229944609191,22.062990949635815,0 +Clustering,10.0,25.42500380318439,22.8805605133875,0 +Clustering,12.0,26.866974591933545,23.642698908232344,0 +Clustering,14.0,28.25440857977878,24.295577797395794,0 +Clustering,16.0,29.473448548575952,24.755496878832897,0 +Clustering,18.0,30.35343388369394,24.887280488036616,0 +Clustering,20.0,31.277527604475182,25.019131677616947,0 +Clustering,22.0,32.24973677183039,25.151527870234474,0 +Clustering,24.0,33.272467949806014,25.283409579984887,0 +Clustering,26.0,34.35025017685175,25.41509508864191,0 +Clustering,28.0,35.48902755915657,25.54755886163605,0 +Clustering,30.0,36.692041169607634,25.679407871204234,0 +Clustering,32.0,37.08143321299699,25.214320198963634,0 +Clustering,34.0,37.801741165142474,24.944984058007165,0 +Clustering,36.0,38.56041236036592,24.678115690803104,0 +Clustering,38.0,39.375093895702,24.408779549846635,0 +Clustering,40.0,40.244325687907576,24.139443408890155,0 +Clustering,42.0,41.16541424355492,23.872575041686094,0 +Clustering,44.0,42.1611254225709,23.60333700127636,0 +Clustering,46.0,43.22108781644587,23.33646863407234,0 +Clustering,48.0,44.37254564981492,23.06709979293367,0 +Clustering,50.0,45.605325690523784,22.800231425729635,0 +Clustering,52.0,46.956324710509435,22.532693794795932,0 +Clustering,54.0,48.40808271426489,22.265825427591906,0 +Clustering,56.0,50.001517853971365,21.994625376248255,0 +Clustering,58.0,51.735819520096896,21.72775700904422,0 +Clustering,60.0,53.66205737551301,21.45910103187818,0 +Clustering,62.0,55.770598262146756,21.192232664674126,0 +Clustering,64.0,58.134079961959415,20.922896523717665,0 +Clustering,66.0,60.77689795722113,20.653560382761206,0 +Clustering,68.0,63.72398398596886,20.38669201555716,0 +Clustering,70.0,67.09371070976744,20.1173820347465,0 +Clustering,72.0,70.91089411329523,19.85051366754247,0 +Clustering,74.0,75.35473310814974,19.581249466986932,0 +Clustering,76.0,80.49327688378013,19.31438109978297,0 +Clustering,78.0,86.6255685897794,19.046233065447634,0 +Clustering,80.0,93.91961841174937,18.780585505046925,0 +Clustering,82.0,98.93886286593397,18.623785951234378,0 +Clustering,84.0,98.93886286593397,18.623785951234378,0 +Clustering,86.0,98.93886286593397,18.623785951234378,0 +Clustering,88.0,98.93886286593397,18.623785951234378,0 +Clustering,90.0,98.93886286593397,18.623785951234378,0 +Clustering,92.0,98.93886286593397,18.623785951234378,0 +Clustering,94.0,98.93886286593397,18.623785951234378,0 +Clustering,96.0,98.93886286593397,18.623785951234378,0 +Clustering,98.0,98.93886286593397,18.623785951234378,0 +Clustering,100.0,98.93886286593397,18.623785951234378,0 +Clustering,102.0,98.93886286593397,18.623785951234378,0 +Clustering,104.0,98.93886286593397,18.623785951234378,0 +Clustering,106.0,98.93886286593397,18.623785951234378,0 +Clustering,108.0,98.93886286593397,18.623785951234378,0 +FGD-Full,0.0,13.872568349048816,13.872568349048816,0 +FGD-Full,2.0,15.219608356525532,14.914675240102094,0 +FGD-Full,4.0,15.98594917117691,15.346056654504439,0 +FGD-Full,6.0,16.712781990915275,15.708886431482261,0 +FGD-Full,8.0,16.95395079543038,15.597122527844387,0 +FGD-Full,10.0,17.183557806669892,15.463888905360074,0 +FGD-Full,12.0,18.067984029402748,15.899665398655321,0 +FGD-Full,14.0,19.1818311788984,16.49419312343945,0 +FGD-Full,16.0,20.095218015542105,16.878483223411333,0 +FGD-Full,18.0,20.737758405428927,17.00322975339877,0 +FGD-Full,20.0,21.421322926767665,17.13507876296694,0 +FGD-Full,22.0,22.140666571418073,17.2674771355966,0 +FGD-Full,24.0,22.897083704247475,17.399260744800305,0 +FGD-Full,26.0,23.694504337837017,17.531111934380622,0 +FGD-Full,28.0,24.537010761202698,17.663508126998135,0 +FGD-Full,30.0,25.426956096265112,17.795389836748534,0 +FGD-Full,32.0,25.930698895211044,17.632137926578288,0 +FGD-Full,34.0,26.291691137534954,17.34961925215822,0 +FGD-Full,36.0,26.67178963870641,17.069566171478414,0 +FGD-Full,38.0,27.07996207907811,16.786977736669584,0 +FGD-Full,40.0,27.51558163761512,16.50445906224952,0 +FGD-Full,42.0,27.97705701712837,16.22440598156971,0 +FGD-Full,44.0,28.48836049881808,15.94882410580703,0 +FGD-Full,46.0,29.04655204430313,15.683176545406294,0 +FGD-Full,48.0,29.652861149911814,15.415061211253148,0 +FGD-Full,50.0,31.242707474171876,15.619688051597608,0 +FGD-Full,52.0,36.84279465650782,17.679565333481744,0 +FGD-Full,54.0,48.04855113935601,22.10045495981523,0 +FGD-Full,56.0,62.37171633675732,27.436017820639936,0 +FGD-Full,58.0,76.6138572459498,32.557145094457915,0 +FGD-Full,60.0,76.6138572459498,32.557145094457915,0 +FGD-Full,62.0,76.6138572459498,32.557145094457915,0 +FGD-Full,64.0,76.6138572459498,32.557145094457915,0 +FGD-Full,66.0,76.6138572459498,32.557145094457915,0 +FGD-Full,68.0,76.6138572459498,32.557145094457915,0 +FGD-Full,70.0,76.6138572459498,32.557145094457915,0 +FGD-Full,72.0,76.6138572459498,32.557145094457915,0 +FGD-Full,74.0,76.6138572459498,32.557145094457915,0 +FGD-Full,76.0,76.6138572459498,32.557145094457915,0 +FGD-Full,78.0,76.6138572459498,32.557145094457915,0 +FGD-Full,80.0,76.6138572459498,32.557145094457915,0 +FGD-Full,82.0,76.6138572459498,32.557145094457915,0 +FGD-Full,84.0,76.6138572459498,32.557145094457915,0 +FGD-Full,86.0,76.6138572459498,32.557145094457915,0 +FGD-Full,88.0,76.6138572459498,32.557145094457915,0 +FGD-Full,90.0,76.6138572459498,32.557145094457915,0 +FGD-Full,92.0,76.6138572459498,32.557145094457915,0 +FGD-Full,94.0,76.6138572459498,32.557145094457915,0 +FGD-Full,96.0,76.6138572459498,32.557145094457915,0 +FGD-Full,98.0,76.6138572459498,32.557145094457915,0 +FGD-Full,100.0,76.6138572459498,32.557145094457915,0 +FGD-Full,102.0,76.70519880364591,32.51417099457185,0 +FGD-Full,104.0,76.70519880364591,32.51417099457185,0 +FGD-Full,106.0,76.70519880364591,32.51417099457185,0 +FGD-Full,108.0,76.70519880364591,32.51417099457185,0 +FGD-2000,0.0,13.872568349048816,13.872568349048816,0 +FGD-2000,2.0,26.150524030573607,25.626584084028913,0 +FGD-2000,4.0,30.97556662846533,29.73566319370512,0 +FGD-2000,6.0,33.2500413536282,31.252793445768496,0 +FGD-2000,8.0,35.337118874657634,32.509081778012,0 +FGD-2000,10.0,37.58311769519086,33.821933926274355,0 +FGD-2000,12.0,39.327643802887906,34.607977091735805,0 +FGD-2000,14.0,40.992815895658396,35.249159256515725,0 +FGD-2000,16.0,42.205406413694504,35.44939117056815,0 +FGD-2000,18.0,43.38697184402901,35.57369297807721,0 +FGD-2000,20.0,44.637083714237704,35.70554198764531,0 +FGD-2000,22.0,45.95204510145125,35.8379403602749,0 +FGD-2000,24.0,47.33544675419366,35.96972396947854,0 +FGD-2000,26.0,48.793763476662754,36.10157515905878,0 +FGD-2000,28.0,50.33390528002014,36.23397135167622,0 +FGD-2000,30.0,51.96137638337189,36.365853061426556,0 +FGD-2000,32.0,53.05279876148702,36.07439463678701,0 +FGD-2000,34.0,54.260177592827816,35.80573865962095,0 +FGD-2000,36.0,55.52082979073598,35.532541717148966,0 +FGD-2000,38.0,56.86356491019108,35.24995328234003,0 +FGD-2000,40.0,58.296324525588474,34.96743460791984,0 +FGD-2000,42.0,59.814260803438444,34.68738152723992,0 +FGD-2000,44.0,61.45507292588104,34.404793092430985,0 +FGD-2000,46.0,63.20186691005352,34.124740011751065,0 +FGD-2000,48.0,65.10741936805258,33.846138819162256,0 +FGD-2000,50.0,67.16814457310275,33.580491258761555,0 +FGD-2000,52.0,69.42031676460007,33.31237592460843,0 +FGD-2000,54.0,70.21920833256875,33.22153481836912,0 +FGD-2000,56.0,70.21920833256875,33.22153481836912,0 +FGD-2000,58.0,70.21920833256875,33.22153481836912,0 +FGD-2000,60.0,70.21920833256875,33.22153481836912,0 +FGD-2000,62.0,70.21920833256875,33.22153481836912,0 +FGD-2000,64.0,70.21920833256875,33.22153481836912,0 +FGD-2000,66.0,70.21920833256875,33.22153481836912,0 +FGD-2000,68.0,70.21920833256875,33.22153481836912,0 +FGD-2000,70.0,70.21920833256875,33.22153481836912,0 +FGD-2000,72.0,70.21920833256875,33.22153481836912,0 +FGD-2000,74.0,70.21920833256875,33.22153481836912,0 +FGD-2000,76.0,70.21920833256875,33.22153481836912,0 +FGD-2000,78.0,70.21920833256875,33.22153481836912,0 +FGD-2000,80.0,70.21920833256875,33.22153481836912,0 +FGD-2000,82.0,70.21920833256875,33.22153481836912,0 +FGD-2000,84.0,70.21920833256875,33.22153481836912,0 +FGD-2000,86.0,70.21920833256875,33.22153481836912,0 +FGD-2000,88.0,70.21920833256875,33.22153481836912,0 +FGD-2000,90.0,70.21920833256875,33.22153481836912,0 +FGD-2000,92.0,70.21920833256875,33.22153481836912,0 +FGD-2000,94.0,70.21920833256875,33.22153481836912,0 +FGD-2000,96.0,70.21920833256875,33.22153481836912,0 +FGD-2000,98.0,70.21920833256875,33.22153481836912,0 +FGD-2000,100.0,70.21920833256875,33.22153481836912,0 +FGD-2000,102.0,70.24972380245586,33.161065641386486,0 +FGD-2000,104.0,70.24972380245586,33.161065641386486,0 +FGD-2000,106.0,70.24972380245586,33.161065641386486,0 +FGD-2000,108.0,70.24972380245586,33.161065641386486,0 diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure9.png b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9.png new file mode 100644 index 0000000..a649de5 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9a_unalloc.csv new file mode 100644 index 0000000..89294e7 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.99644570819311,0 +Random,4.0,95.99715656655451,0 +Random,6.0,93.99324684556628,0 +Random,8.0,91.99697885196395,0 +Random,10.0,89.99235827261445,0 +Random,12.0,87.99911142704838,0 +Random,14.0,85.98862626621666,0 +Random,16.0,83.9925359872048,0 +Random,18.0,81.99164741425288,0 +Random,20.0,79.99075884130107,0 +Random,22.0,77.98987026834907,0 +Random,24.0,75.98898169539719,0 +Random,26.0,73.98809312244529,0 +Random,28.0,71.98720454949343,0 +Random,30.0,69.98631597654156,0 +Random,32.0,67.99715656655398,0 +Random,34.0,65.98898169539707,0 +Random,36.0,63.99857828327694,0 +Random,38.0,61.99040341212001,0 +Random,40.0,59.98222854096312,0 +Random,42.0,57.99182512884299,0 +Random,44.0,55.983650257686065,0 +Random,46.0,53.99324684556595,0 +Random,48.0,51.985071974409,0 +Random,50.0,49.99466856228887,0 +Random,52.0,47.98649369113195,0 +Random,54.0,45.996090279011824,0 +Random,56.0,43.9879154078549,0 +Random,58.0,41.99751199573478,0 +Random,60.0,39.989337124577936,0 +Random,62.0,37.998933712457905,0 +Random,64.0,35.99075884130099,0 +Random,66.0,33.98258397014406,0 +Random,68.0,31.992180558023932,0 +Random,70.0,29.984005686867,0 +Random,72.0,27.993602274746866,0 +Random,74.0,25.98542740358995,0 +Random,76.0,23.995023991469793,0 +Random,78.0,22.271192464901453,0 +Random,80.0,22.271192464901453,0 +Random,82.0,22.271192464901453,0 +Random,84.0,22.271192464901453,0 +Random,86.0,22.271192464901453,0 +Random,88.0,22.271192464901453,0 +Random,90.0,22.271192464901453,0 +Random,92.0,22.271192464901453,0 +Random,94.0,22.271192464901453,0 +Random,96.0,22.271192464901453,0 +Random,98.0,22.271192464901453,0 +Random,100.0,22.271192464901453,0 +Random,102.0,22.16456371068074,0 +Random,104.0,22.16456371068074,0 +Random,106.0,22.16456371068074,0 +Random,108.0,22.16456371068074,0 +Clustering,2.0,97.99644570819292,0 +Clustering,4.0,95.9971565665544,0 +Clustering,6.0,93.99324684556618,0 +Clustering,8.0,91.99697885196383,0 +Clustering,10.0,89.99235827261428,0 +Clustering,12.0,87.99911142704823,0 +Clustering,14.0,85.98862626621654,0 +Clustering,16.0,83.99253598720462,0 +Clustering,18.0,81.99164741425261,0 +Clustering,20.0,79.99075884130053,0 +Clustering,22.0,77.98987026834871,0 +Clustering,24.0,75.98898169539687,0 +Clustering,26.0,73.98809312244504,0 +Clustering,28.0,71.9872045494932,0 +Clustering,30.0,69.98631597654135,0 +Clustering,32.0,67.99715656655378,0 +Clustering,34.0,65.98898169539686,0 +Clustering,36.0,63.99857828327673,0 +Clustering,38.0,61.99040341211981,0 +Clustering,40.0,59.98222854096289,0 +Clustering,42.0,57.991825128842756,0 +Clustering,44.0,55.983650257685824,0 +Clustering,46.0,53.99324684556569,0 +Clustering,48.0,51.98507197440877,0 +Clustering,50.0,49.99466856228864,0 +Clustering,52.0,47.98649369113171,0 +Clustering,54.0,45.99609027901164,0 +Clustering,56.0,43.987915407854636,0 +Clustering,58.0,41.99751199573445,0 +Clustering,60.0,39.98933712457765,0 +Clustering,62.0,37.998933712457514,0 +Clustering,64.0,35.99075884130059,0 +Clustering,66.0,33.98258397014367,0 +Clustering,68.0,31.992180558023538,0 +Clustering,70.0,29.984005686866617,0 +Clustering,72.0,27.993602274746465,0 +Clustering,74.0,25.98542740358958,0 +Clustering,76.0,23.99502399146945,0 +Clustering,78.0,21.986849120312524,0 +Clustering,80.0,19.99644570819239,0 +Clustering,82.0,18.823529411764454,0 +Clustering,84.0,18.823529411764454,0 +Clustering,86.0,18.823529411764454,0 +Clustering,88.0,18.823529411764454,0 +Clustering,90.0,18.823529411764454,0 +Clustering,92.0,18.823529411764454,0 +Clustering,94.0,18.823529411764454,0 +Clustering,96.0,18.823529411764454,0 +Clustering,98.0,18.823529411764454,0 +Clustering,100.0,18.823529411764454,0 +Clustering,102.0,18.823529411764454,0 +Clustering,104.0,18.823529411764454,0 +Clustering,106.0,18.823529411764454,0 +Clustering,108.0,18.823529411764454,0 +FGD-Full,2.0,97.99644570819262,0 +FGD-Full,4.0,95.99715656655398,0 +FGD-Full,6.0,93.99324684556579,0 +FGD-Full,8.0,91.99697885196352,0 +FGD-Full,10.0,89.99235827261384,0 +FGD-Full,12.0,87.99911142704777,0 +FGD-Full,14.0,85.98862626621604,0 +FGD-Full,16.0,83.99253598720415,0 +FGD-Full,18.0,81.99164741425237,0 +FGD-Full,20.0,79.99075884130052,0 +FGD-Full,22.0,77.98987026834867,0 +FGD-Full,24.0,75.98898169539683,0 +FGD-Full,26.0,73.98809312244498,0 +FGD-Full,28.0,71.98720454949314,0 +FGD-Full,30.0,69.98631597654129,0 +FGD-Full,32.0,67.99715656655377,0 +FGD-Full,34.0,65.98898169539686,0 +FGD-Full,36.0,63.99857828327672,0 +FGD-Full,38.0,61.99040341211979,0 +FGD-Full,40.0,59.982228540962865,0 +FGD-Full,42.0,57.991825128842734,0 +FGD-Full,44.0,55.98365025768581,0 +FGD-Full,46.0,53.99324684556568,0 +FGD-Full,48.0,51.98507197440876,0 +FGD-Full,50.0,49.99466856228863,0 +FGD-Full,52.0,47.986493691131734,0 +FGD-Full,54.0,45.99609027901156,0 +FGD-Full,56.0,43.98791540785476,0 +FGD-Full,58.0,42.49511284876478,0 +FGD-Full,60.0,42.49511284876478,0 +FGD-Full,62.0,42.49511284876478,0 +FGD-Full,64.0,42.49511284876478,0 +FGD-Full,66.0,42.49511284876478,0 +FGD-Full,68.0,42.49511284876478,0 +FGD-Full,70.0,42.49511284876478,0 +FGD-Full,72.0,42.49511284876478,0 +FGD-Full,74.0,42.49511284876478,0 +FGD-Full,76.0,42.49511284876478,0 +FGD-Full,78.0,42.49511284876478,0 +FGD-Full,80.0,42.49511284876478,0 +FGD-Full,82.0,42.49511284876478,0 +FGD-Full,84.0,42.49511284876478,0 +FGD-Full,86.0,42.49511284876478,0 +FGD-Full,88.0,42.49511284876478,0 +FGD-Full,90.0,42.49511284876478,0 +FGD-Full,92.0,42.49511284876478,0 +FGD-Full,94.0,42.49511284876478,0 +FGD-Full,96.0,42.49511284876478,0 +FGD-Full,98.0,42.49511284876478,0 +FGD-Full,100.0,42.49511284876478,0 +FGD-Full,102.0,42.38848409454406,0 +FGD-Full,104.0,42.38848409454406,0 +FGD-Full,106.0,42.38848409454406,0 +FGD-Full,108.0,42.38848409454406,0 +FGD-2000,2.0,97.99644570819255,0 +FGD-2000,4.0,95.99715656655403,0 +FGD-2000,6.0,93.99324684556592,0 +FGD-2000,8.0,91.99697885196355,0 +FGD-2000,10.0,89.99235827261401,0 +FGD-2000,12.0,87.99911142704784,0 +FGD-2000,14.0,85.9886262662161,0 +FGD-2000,16.0,83.99253598720419,0 +FGD-2000,18.0,81.99164741425236,0 +FGD-2000,20.0,79.99075884130052,0 +FGD-2000,22.0,77.98987026834867,0 +FGD-2000,24.0,75.98898169539683,0 +FGD-2000,26.0,73.98809312244498,0 +FGD-2000,28.0,71.98720454949313,0 +FGD-2000,30.0,69.98631597654128,0 +FGD-2000,32.0,67.99715656655374,0 +FGD-2000,34.0,65.98898169539682,0 +FGD-2000,36.0,63.998578283276686,0 +FGD-2000,38.0,61.99040341211977,0 +FGD-2000,40.0,59.982228540962836,0 +FGD-2000,42.0,57.9918251288427,0 +FGD-2000,44.0,55.98365025768578,0 +FGD-2000,46.0,53.99324684556564,0 +FGD-2000,48.0,51.985071974408726,0 +FGD-2000,50.0,49.99466856228859,0 +FGD-2000,52.0,47.98649369113166,0 +FGD-2000,54.0,47.311178247733764,0 +FGD-2000,56.0,47.311178247733764,0 +FGD-2000,58.0,47.311178247733764,0 +FGD-2000,60.0,47.311178247733764,0 +FGD-2000,62.0,47.311178247733764,0 +FGD-2000,64.0,47.311178247733764,0 +FGD-2000,66.0,47.311178247733764,0 +FGD-2000,68.0,47.311178247733764,0 +FGD-2000,70.0,47.311178247733764,0 +FGD-2000,72.0,47.311178247733764,0 +FGD-2000,74.0,47.311178247733764,0 +FGD-2000,76.0,47.311178247733764,0 +FGD-2000,78.0,47.311178247733764,0 +FGD-2000,80.0,47.311178247733764,0 +FGD-2000,82.0,47.311178247733764,0 +FGD-2000,84.0,47.311178247733764,0 +FGD-2000,86.0,47.311178247733764,0 +FGD-2000,88.0,47.311178247733764,0 +FGD-2000,90.0,47.311178247733764,0 +FGD-2000,92.0,47.311178247733764,0 +FGD-2000,94.0,47.311178247733764,0 +FGD-2000,96.0,47.311178247733764,0 +FGD-2000,98.0,47.311178247733764,0 +FGD-2000,100.0,47.311178247733764,0 +FGD-2000,102.0,47.20454949351304,0 +FGD-2000,104.0,47.20454949351304,0 +FGD-2000,106.0,47.20454949351304,0 +FGD-2000,108.0,47.20454949351304,0 diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9b_occupied.csv new file mode 100644 index 0000000..70e56a9 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,832,0 +Random,4.0,899,0 +Random,6.0,938,0 +Random,8.0,982,0 +Random,10.0,1014,0 +Random,12.0,1027,0 +Random,14.0,1037,0 +Random,16.0,1045,0 +Random,18.0,1053,0 +Random,20.0,1059,0 +Random,22.0,1069,0 +Random,24.0,1073,0 +Random,26.0,1078,0 +Random,28.0,1081,0 +Random,30.0,1085,0 +Random,32.0,1086,0 +Random,34.0,1087,0 +Random,36.0,1088,0 +Random,38.0,1089,0 +Random,40.0,1090,0 +Random,42.0,1091,0 +Random,44.0,1093,0 +Random,46.0,1094,0 +Random,48.0,1095,0 +Random,50.0,1095,0 +Random,52.0,1097,0 +Random,54.0,1098,0 +Random,56.0,1098,0 +Random,58.0,1099,0 +Random,60.0,1099,0 +Random,62.0,1099,0 +Random,64.0,1099,0 +Random,66.0,1099,0 +Random,68.0,1099,0 +Random,70.0,1099,0 +Random,72.0,1099,0 +Random,74.0,1099,0 +Random,76.0,1099,0 +Random,78.0,1099,0 +Random,80.0,1099,0 +Random,82.0,1099,0 +Random,84.0,1099,0 +Random,86.0,1099,0 +Random,88.0,1099,0 +Random,90.0,1099,0 +Random,92.0,1099,0 +Random,94.0,1099,0 +Random,96.0,1099,0 +Random,98.0,1099,0 +Random,100.0,1099,0 +Random,102.0,1099,0 +Random,104.0,1099,0 +Random,106.0,1099,0 +Random,108.0,1099,0 +Clustering,2.0,340,0 +Clustering,4.0,402,0 +Clustering,6.0,463,0 +Clustering,8.0,527,0 +Clustering,10.0,560,0 +Clustering,12.0,579,0 +Clustering,14.0,601,0 +Clustering,16.0,621,0 +Clustering,18.0,638,0 +Clustering,20.0,655,0 +Clustering,22.0,673,0 +Clustering,24.0,690,0 +Clustering,26.0,707,0 +Clustering,28.0,725,0 +Clustering,30.0,742,0 +Clustering,32.0,755,0 +Clustering,34.0,769,0 +Clustering,36.0,783,0 +Clustering,38.0,797,0 +Clustering,40.0,811,0 +Clustering,42.0,825,0 +Clustering,44.0,839,0 +Clustering,46.0,853,0 +Clustering,48.0,867,0 +Clustering,50.0,881,0 +Clustering,52.0,895,0 +Clustering,54.0,909,0 +Clustering,56.0,923,0 +Clustering,58.0,937,0 +Clustering,60.0,952,0 +Clustering,62.0,966,0 +Clustering,64.0,980,0 +Clustering,66.0,994,0 +Clustering,68.0,1008,0 +Clustering,70.0,1022,0 +Clustering,72.0,1036,0 +Clustering,74.0,1050,0 +Clustering,76.0,1064,0 +Clustering,78.0,1078,0 +Clustering,80.0,1092,0 +Clustering,82.0,1100,0 +Clustering,84.0,1100,0 +Clustering,86.0,1100,0 +Clustering,88.0,1100,0 +Clustering,90.0,1100,0 +Clustering,92.0,1100,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,404,0 +FGD-Full,4.0,404,0 +FGD-Full,6.0,408,0 +FGD-Full,8.0,436,0 +FGD-Full,10.0,476,0 +FGD-Full,12.0,523,0 +FGD-Full,14.0,562,0 +FGD-Full,16.0,596,0 +FGD-Full,18.0,606,0 +FGD-Full,20.0,623,0 +FGD-Full,22.0,641,0 +FGD-Full,24.0,658,0 +FGD-Full,26.0,675,0 +FGD-Full,28.0,693,0 +FGD-Full,30.0,710,0 +FGD-Full,32.0,749,0 +FGD-Full,34.0,806,0 +FGD-Full,36.0,862,0 +FGD-Full,38.0,918,0 +FGD-Full,40.0,975,0 +FGD-Full,42.0,1031,0 +FGD-Full,44.0,1069,0 +FGD-Full,46.0,1083,0 +FGD-Full,48.0,1097,0 +FGD-Full,50.0,1100,0 +FGD-Full,52.0,1100,0 +FGD-Full,54.0,1100,0 +FGD-Full,56.0,1100,0 +FGD-Full,58.0,1100,0 +FGD-Full,60.0,1100,0 +FGD-Full,62.0,1100,0 +FGD-Full,64.0,1100,0 +FGD-Full,66.0,1100,0 +FGD-Full,68.0,1100,0 +FGD-Full,70.0,1100,0 +FGD-Full,72.0,1100,0 +FGD-Full,74.0,1100,0 +FGD-Full,76.0,1100,0 +FGD-Full,78.0,1100,0 +FGD-Full,80.0,1100,0 +FGD-Full,82.0,1100,0 +FGD-Full,84.0,1100,0 +FGD-Full,86.0,1100,0 +FGD-Full,88.0,1100,0 +FGD-Full,90.0,1100,0 +FGD-Full,92.0,1100,0 +FGD-Full,94.0,1100,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,387,0 +FGD-2000,4.0,387,0 +FGD-2000,6.0,413,0 +FGD-2000,8.0,444,0 +FGD-2000,10.0,478,0 +FGD-2000,12.0,495,0 +FGD-2000,14.0,520,0 +FGD-2000,16.0,556,0 +FGD-2000,18.0,573,0 +FGD-2000,20.0,590,0 +FGD-2000,22.0,608,0 +FGD-2000,24.0,625,0 +FGD-2000,26.0,642,0 +FGD-2000,28.0,660,0 +FGD-2000,30.0,677,0 +FGD-2000,32.0,689,0 +FGD-2000,34.0,704,0 +FGD-2000,36.0,736,0 +FGD-2000,38.0,792,0 +FGD-2000,40.0,849,0 +FGD-2000,42.0,905,0 +FGD-2000,44.0,961,0 +FGD-2000,46.0,1017,0 +FGD-2000,48.0,1064,0 +FGD-2000,50.0,1078,0 +FGD-2000,52.0,1092,0 +FGD-2000,54.0,1098,0 +FGD-2000,56.0,1098,0 +FGD-2000,58.0,1098,0 +FGD-2000,60.0,1098,0 +FGD-2000,62.0,1098,0 +FGD-2000,64.0,1098,0 +FGD-2000,66.0,1098,0 +FGD-2000,68.0,1098,0 +FGD-2000,70.0,1098,0 +FGD-2000,72.0,1098,0 +FGD-2000,74.0,1098,0 +FGD-2000,76.0,1098,0 +FGD-2000,78.0,1098,0 +FGD-2000,80.0,1098,0 +FGD-2000,82.0,1098,0 +FGD-2000,84.0,1098,0 +FGD-2000,86.0,1098,0 +FGD-2000,88.0,1098,0 +FGD-2000,90.0,1098,0 +FGD-2000,92.0,1098,0 +FGD-2000,94.0,1098,0 +FGD-2000,96.0,1098,0 +FGD-2000,98.0,1098,0 +FGD-2000,100.0,1098,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9c_failed.csv new file mode 100644 index 0000000..7521724 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9c_failed.csv @@ -0,0 +1,5 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,1,1029.0,0 +Clustering,1,835.0,0 +FGD-Full,1,2167.0,0 +FGD-2000,1,2438.0,0 diff --git a/standalone_fgd_replication/result/dist-shift-ascending-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9d_breakdown.csv new file mode 100644 index 0000000..d301bed --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-ascending-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,41.14659779074593,0 +Random,stranded,43.76004775437971,0 +Random,non_gpu,15.093354454874358,0 +Clustering,deficient,30.671487617295206,0 +Clustering,stranded,55.838951586959865,0 +Clustering,non_gpu,13.489560795744934,0 +FGD-Full,deficient,17.77984688692697,0 +FGD-Full,stranded,64.82052666652206,0 +FGD-Full,non_gpu,17.399626446550972,0 +FGD-2000,deficient,36.91338506882361,0 +FGD-2000,stranded,44.088080368322586,0 +FGD-2000,non_gpu,18.998534562853813,0 diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-descending-90/experiment_summary.log new file mode 100644 index 0000000..f2cf4c4 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-descending-90/experiment_summary.log @@ -0,0 +1,23 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-descending-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: descending +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 4 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 99.2 95.0 6476 1676 25.0 +Clustering 99.0 94.2 6368 1784 25.7 +FGD-Full 99.1 94.3 6359 1793 86.7 +FGD-2000 99.7 95.2 6460 1692 73.6 diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure7.png b/standalone_fgd_replication/result/dist-shift-descending-90/figure7.png new file mode 100644 index 0000000..1e5d3a9 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-descending-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-descending-90/figure7_results.csv new file mode 100644 index 0000000..16e2820 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-descending-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.872568349048816,13.872568349048816,0 +Random,2.0,13.883231494290438,13.587161158531622,0 +Random,4.0,13.893102416459746,13.320292791327587,0 +Random,6.0,13.90357762423095,13.053598825095452,0 +Random,8.0,13.99014740032117,12.868847155511354,0 +Random,10.0,14.204863226655517,12.7836195805551,0 +Random,12.0,14.274931125817961,12.560011374431262,0 +Random,14.0,14.341760528061332,12.333353331311317,0 +Random,16.0,14.602451849061495,12.264294906462524,0 +Random,18.0,14.809013975046135,12.143023010638505,0 +Random,20.0,14.991249354902763,11.991400985679286,0 +Random,22.0,15.136022879037029,11.805936452122538,0 +Random,24.0,15.307264752673772,11.632106643403777,0 +Random,26.0,15.448848175795915,11.429457074078265,0 +Random,28.0,15.62699174824213,11.250212115181956,0 +Random,30.0,15.78097034954436,11.044155186867902,0 +Random,32.0,16.030589346073164,10.899775162266916,0 +Random,34.0,16.22828723946059,10.708304695240303,0 +Random,36.0,16.466169439902988,10.537529083541967,0 +Random,38.0,16.777162805772726,10.399634595083574,0 +Random,40.0,17.033033355580308,10.219214609639081,0 +Random,42.0,17.294169739100372,10.0285899873262,0 +Random,44.0,17.57786209901418,9.843227914340444,0 +Random,46.0,17.850884220223815,9.637637508626257,0 +Random,48.0,18.267112323139877,9.498768554737387,0 +Random,50.0,18.80993700563798,9.403297102694088,0 +Random,52.0,19.2601452040853,9.241583801498189,0 +Random,54.0,19.905864122628277,9.155211720163848,0 +Random,56.0,20.48430824436705,9.009892110326719,0 +Random,58.0,21.079343302475063,8.85205051070705,0 +Random,60.0,21.39458074364837,8.554790594136987,0 +Random,62.0,21.847514162621977,8.30104590006856,0 +Random,64.0,22.42107367426297,8.068717645349656,0 +Random,66.0,22.863694868076227,7.772924876955717,0 +Random,68.0,22.78269817904252,7.287872173854014,0 +Random,70.0,22.823354196800942,6.846600654736092,0 +Random,72.0,22.668341199744418,6.344879578744883,0 +Random,74.0,22.93809116868349,5.96382217518819,0 +Random,76.0,23.05116672118627,5.530313679332053,0 +Random,78.0,23.508076593940284,5.168559999951151,0 +Random,80.0,25.73254966955456,5.146464203415695,0 +Random,82.0,28.785470777773405,5.181077804110371,0 +Random,84.0,32.589368063600304,5.213661813494539,0 +Random,86.0,37.371620727719005,5.230964264717642,0 +Random,88.0,43.88133634652382,5.264122707303011,0 +Random,90.0,53.6398768589181,5.36150921281853,0 +Random,92.0,68.46407776531787,5.473354430909562,0 +Random,94.0,97.0306507330551,5.812354974691793,0 +Random,96.0,98.24009051172233,5.805366073744044,0 +Random,98.0,98.24009051172233,5.805366073744044,0 +Random,100.0,98.24009051172233,5.805366073744044,0 +Random,102.0,98.24009051172233,5.805366073744044,0 +Random,104.0,98.24009051172233,5.805366073744044,0 +Random,106.0,98.99048302808174,5.320012790567271,0 +Random,108.0,98.99825901437158,5.095762527265406,0 +Clustering,0.0,13.872568349048816,13.872568349048816,0 +Clustering,2.0,13.883142393666786,13.587073958045673,0 +Clustering,4.0,13.892684044852993,13.319891669092215,0 +Clustering,6.0,13.902295900881468,13.052395458389334,0 +Clustering,8.0,13.86506786436372,12.753792654335635,0 +Clustering,10.0,13.860531710300423,12.473739573655829,0 +Clustering,12.0,13.85570742441771,12.191151138847001,0 +Clustering,14.0,13.91432183025504,11.96577276285839,0 +Clustering,16.0,15.391581845070526,12.9270687399686,0 +Clustering,18.0,15.42365780555224,12.647015659288794,0 +Clustering,20.0,15.457681522740796,12.364496984868726,0 +Clustering,22.0,15.493088596234006,12.08444390418892,0 +Clustering,24.0,16.18047726957673,12.295667461295558,0 +Clustering,26.0,16.41684820031216,12.145608505047008,0 +Clustering,28.0,16.500042151479242,11.878740137842975,0 +Clustering,30.0,16.5886905773542,11.609430157032316,0 +Clustering,32.0,16.68180742063872,11.342561789828281,0 +Clustering,34.0,16.781428907847495,11.073297589272748,0 +Clustering,36.0,16.88635857611237,10.806429222068715,0 +Clustering,38.0,16.998885425763618,10.537073461002931,0 +Clustering,40.0,17.11802253045213,10.270205093798898,0 +Clustering,42.0,17.249444134836732,10.002654382792299,0 +Clustering,44.0,17.38410614073628,9.73472870969611,0 +Clustering,46.0,17.53035721553799,9.464585964244607,0 +Clustering,48.0,17.68816025924376,9.197717597040562,0 +Clustering,50.0,17.86129745290934,8.92906161987453,0 +Clustering,52.0,18.047509359211876,8.659725478918086,0 +Clustering,54.0,18.248302537718303,8.39285711171405,0 +Clustering,56.0,18.469112122203256,8.123520970757609,0 +Clustering,58.0,18.709007278965707,7.856652603553574,0 +Clustering,60.0,18.56845491222318,7.42474205660248,0 +Clustering,62.0,18.84049298134312,7.158516792982334,0 +Clustering,64.0,19.143229261318762,6.889113071649279,0 +Clustering,66.0,19.196819499042373,6.526304549789952,0 +Clustering,68.0,19.56210473230824,6.257648572623925,0 +Clustering,70.0,19.970450364868324,5.990780205419891,0 +Clustering,72.0,20.440994127451315,5.721444064463448,0 +Clustering,74.0,20.97942409328689,5.454575697259414,0 +Clustering,76.0,21.612846654308754,5.185239556302971,0 +Clustering,78.0,22.644521702451588,4.97869609287756,0 +Clustering,80.0,25.551701884770527,5.110294967851771,0 +Clustering,82.0,29.124929072736332,5.2421766776021625,0 +Clustering,84.0,33.59074274011653,5.373862186259165,0 +Clustering,86.0,39.33888953139607,5.506325959253279,0 +Clustering,88.0,46.99940824786783,5.638174968821441,0 +Clustering,90.0,57.73240913225468,5.770573341451102,0 +Clustering,92.0,73.84666604057189,5.903664957944069,0 +Clustering,94.0,98.47932575691347,6.194904378563118,0 +Clustering,96.0,98.47932575691347,6.194904378563118,0 +Clustering,98.0,98.47932575691347,6.194904378563118,0 +Clustering,100.0,98.47932575691347,6.194904378563118,0 +Clustering,102.0,98.47932575691347,6.194904378563118,0 +Clustering,104.0,98.47932575691347,6.194904378563118,0 +Clustering,106.0,98.97999662317318,5.991218562262798,0 +Clustering,108.0,98.988503257302,5.896034610221667,0 +FGD-Full,0.0,13.872568349048816,13.872568349048816,0 +FGD-Full,2.0,13.883142393666786,13.587073958045673,0 +FGD-Full,4.0,13.892684044852993,13.319891669092215,0 +FGD-Full,6.0,13.902295900881468,13.052395458389334,0 +FGD-Full,8.0,13.865143703178934,12.753862414724393,0 +FGD-Full,10.0,13.881005659452939,12.492165036337246,0 +FGD-Full,12.0,13.911630841917052,12.240356193056929,0 +FGD-Full,14.0,13.942883822783447,11.990334959738599,0 +FGD-Full,16.0,13.964859688765682,11.728794542226161,0 +FGD-Full,18.0,13.989102479844304,11.470715984005974,0 +FGD-Full,20.0,14.016525931757757,11.211726180707599,0 +FGD-Full,22.0,14.044185202054038,10.954314706204936,0 +FGD-Full,24.0,14.069377914112613,10.691427041184562,0 +FGD-Full,26.0,14.092915013494443,10.426302683699548,0 +FGD-Full,28.0,14.118580468990869,10.16427394346579,0 +FGD-Full,30.0,14.145808735099589,9.899803589625408,0 +FGD-Full,32.0,14.17460885619641,9.637827169683218,0 +FGD-Full,34.0,14.204201110756589,9.37270281219819,0 +FGD-Full,36.0,14.236535129948285,9.110674071964416,0 +FGD-Full,38.0,14.271097569347466,8.846203718124038,0 +FGD-Full,40.0,14.307893070755117,8.584227298181851,0 +FGD-Full,42.0,14.346182116855994,8.319102940696837,0 +FGD-Full,44.0,14.388180427167804,8.057074200463079,0 +FGD-Full,46.0,14.433502911437103,7.792603846622698,0 +FGD-Full,48.0,14.482173796968977,7.5306274266805096,0 +FGD-Full,50.0,14.533588969201231,7.265503069195496,0 +FGD-Full,52.0,14.590766183258818,7.001078495610239,0 +FGD-Full,54.0,14.648693752246732,6.737305745657464,0 +FGD-Full,56.0,14.675028003291018,6.454717310848636,0 +FGD-Full,58.0,14.703696835869659,6.17466423016883,0 +FGD-Full,60.0,14.355304765020207,5.740080988323347,0 +FGD-Full,62.0,14.382336632972606,5.464623373253142,0 +FGD-Full,64.0,14.397945213777744,5.181417995006208,0 +FGD-Full,66.0,14.390049590965603,4.892156543009987,0 +FGD-Full,68.0,14.150154018100544,4.526439884944193,0 +FGD-Full,70.0,13.98926905385357,4.196532106434125,0 +FGD-Full,72.0,13.981580136143423,3.913450988879668,0 +FGD-Full,74.0,13.971276773430555,3.6324823030973694,0 +FGD-Full,76.0,13.959800821429807,3.349161384206547,0 +FGD-Full,78.0,14.50667690466401,3.1894838219554247,0 +FGD-Full,80.0,16.51726976061443,3.3034245985245905,0 +FGD-Full,82.0,18.99330376867944,3.418592155130358,0 +FGD-Full,84.0,22.08418651720338,3.5330381277148812,0 +FGD-Full,86.0,26.06728537762713,3.6486787469569313,0 +FGD-Full,88.0,31.446633847858678,3.772422471355962,0 +FGD-Full,90.0,39.07559408016086,3.9057538891852865,0 +FGD-Full,92.0,50.44037959223823,4.032451530045898,0 +FGD-Full,94.0,96.8642329868571,5.847143063558832,0 +FGD-Full,96.0,99.00031342309443,5.896034305019938,0 +FGD-Full,98.0,99.00031342309443,5.896034305019938,0 +FGD-Full,100.0,99.00031342309443,5.896034305019938,0 +FGD-Full,102.0,99.00031342309443,5.896034305019938,0 +FGD-Full,104.0,99.00031342309443,5.896034305019938,0 +FGD-Full,106.0,99.00031342309443,5.896034305019938,0 +FGD-Full,108.0,99.01500132789738,5.78429202710258,0 +FGD-2000,0.0,13.872568349048816,13.872568349048816,0 +FGD-2000,2.0,13.883142393666786,13.587073958045673,0 +FGD-2000,4.0,13.892684044852993,13.319891669092215,0 +FGD-2000,6.0,13.902295900881468,13.052395458389334,0 +FGD-2000,8.0,13.865143703178934,12.753862414724393,0 +FGD-2000,10.0,13.882902382380816,12.493871985849735,0 +FGD-2000,12.0,13.912931616990695,12.241500699435033,0 +FGD-2000,14.0,13.944214704657718,11.991479466116704,0 +FGD-2000,16.0,13.966222392402921,11.729939048604267,0 +FGD-2000,18.0,13.990482309887526,11.471847410311184,0 +FGD-2000,20.0,14.018839778053827,11.213577011021906,0 +FGD-2000,22.0,14.046440706995353,10.956073976008994,0 +FGD-2000,24.0,14.071297131856673,10.69288546931209,0 +FGD-2000,26.0,14.095805682896865,10.428441275617494,0 +FGD-2000,28.0,14.120706211698723,10.165804311994227,0 +FGD-2000,30.0,14.147930060192005,9.901288177898723,0 +FGD-2000,32.0,14.176753805248582,9.639285597810748,0 +FGD-2000,34.0,14.207442117145568,9.374841404116136,0 +FGD-2000,36.0,14.23892651670461,9.112204440492857,0 +FGD-2000,38.0,14.273492574569351,8.847688306397352,0 +FGD-2000,40.0,14.310323928300614,8.585685726309379,0 +FGD-2000,42.0,14.349870090108299,8.321241532614783,0 +FGD-2000,44.0,14.390913332185104,8.058604568991518,0 +FGD-2000,46.0,14.436252673851172,7.794088434896011,0 +FGD-2000,48.0,14.484978504786342,7.532085854808039,0 +FGD-2000,50.0,14.537866913290202,7.267641661113442,0 +FGD-2000,52.0,14.593764765747096,7.002517303628427,0 +FGD-2000,54.0,14.64964173743693,6.737741748087217,0 +FGD-2000,56.0,14.676177872939416,6.455223073667151,0 +FGD-2000,58.0,14.704901206322383,6.175169992987345,0 +FGD-2000,60.0,14.35586631774074,5.74030552957467,0 +FGD-2000,62.0,14.382462859550701,5.464671333520419,0 +FGD-2000,64.0,14.399950326512348,5.182139579027458,0 +FGD-2000,66.0,14.419027243482088,4.902008017910296,0 +FGD-2000,68.0,14.438617653472926,4.618715439177406,0 +FGD-2000,70.0,14.46062286927524,4.337929874415604,0 +FGD-2000,72.0,14.487483838808663,4.055053678003135,0 +FGD-2000,74.0,14.542674153489713,3.7810435909997246,0 +FGD-2000,76.0,14.642814305964464,3.513026357393287,0 +FGD-2000,78.0,15.304244889268691,3.3648396391783457,0 +FGD-2000,80.0,17.39405663762003,3.4787804157475026,0 +FGD-2000,82.0,19.96650673150117,3.593758311296316,0 +FGD-2000,84.0,22.717843592465,3.6344108726449096,0 +FGD-2000,86.0,26.31271116304998,3.683031378397264,0 +FGD-2000,88.0,31.661504536482926,3.7981989350030285,0 +FGD-2000,90.0,39.14006502859174,3.9121980050970477,0 +FGD-2000,92.0,50.91919474193969,4.070730363366177,0 +FGD-2000,94.0,82.83305032125823,5.277644428856826,0 +FGD-2000,96.0,88.35698591356143,5.318063619904893,0 +FGD-2000,98.0,99.00004862626893,5.123652774292147,0 +FGD-2000,100.0,99.00004862626893,5.123652774292147,0 +FGD-2000,102.0,99.00004862626893,5.123652774292147,0 +FGD-2000,104.0,99.00004862626893,5.123652774292147,0 +FGD-2000,106.0,99.02392950405009,5.10535492952192,0 +FGD-2000,108.0,99.03606729937506,4.881226746900398,0 diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure9.png b/standalone_fgd_replication/result/dist-shift-descending-90/figure9.png new file mode 100644 index 0000000..75d5996 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-descending-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-descending-90/figure9a_unalloc.csv new file mode 100644 index 0000000..7594971 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-descending-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.86742491558556,0 +Random,4.0,95.87702150346543,0 +Random,6.0,93.8866180913453,0 +Random,8.0,91.9850719744091,0 +Random,10.0,89.99466856228896,0 +Random,12.0,87.98649369113204,0 +Random,14.0,85.99609027901191,0 +Random,16.0,83.98791540785498,0 +Random,18.0,81.99751199573485,0 +Random,20.0,79.98933712457793,0 +Random,22.0,77.9989337124578,0 +Random,24.0,75.99075884130087,0 +Random,26.0,73.98258397014395,0 +Random,28.0,71.9921805580238,0 +Random,30.0,69.9840056868669,0 +Random,32.0,67.99360227474676,0 +Random,34.0,65.98542740358984,0 +Random,36.0,63.9950239914697,0 +Random,38.0,61.98684912031278,0 +Random,40.0,59.996445708192645,0 +Random,42.0,57.988270837035714,0 +Random,44.0,55.99786742491558,0 +Random,46.0,53.98969255375866,0 +Random,48.0,51.99928914163853,0 +Random,50.0,49.99111427048161,0 +Random,52.0,47.982939399324685,0 +Random,54.0,45.99253598720455,0 +Random,56.0,43.98436111604763,0 +Random,58.0,41.99395770392749,0 +Random,60.0,39.985782832770575,0 +Random,62.0,37.99537942065044,0 +Random,64.0,35.98720454949351,0 +Random,66.0,33.99680113737338,0 +Random,68.0,31.988626266216457,0 +Random,70.0,29.998222854096323,0 +Random,72.0,27.990047982939398,0 +Random,74.0,25.999644570819264,0 +Random,76.0,23.991469699662343,0 +Random,78.0,21.986315976541697,0 +Random,80.0,19.999822285409703,0 +Random,82.0,17.99893371245789,0 +Random,84.0,15.998045139506031,0 +Random,86.0,13.997156566554173,0 +Random,88.0,11.996267993602304,0 +Random,90.0,9.995379420650426,0 +Random,92.0,7.99449084769856,0 +Random,94.0,5.990225697529737,0 +Random,96.0,5.909365558912355,0 +Random,98.0,5.909365558912355,0 +Random,100.0,5.909365558912355,0 +Random,102.0,5.909365558912355,0 +Random,104.0,5.909365558912355,0 +Random,106.0,5.374266927314703,0 +Random,108.0,5.147325395414937,0 +Clustering,2.0,97.86742491558556,0 +Clustering,4.0,95.87702150346543,0 +Clustering,6.0,93.8866180913453,0 +Clustering,8.0,91.9850719744091,0 +Clustering,10.0,89.99466856228896,0 +Clustering,12.0,87.98649369113204,0 +Clustering,14.0,85.99609027901191,0 +Clustering,16.0,83.98791540785498,0 +Clustering,18.0,81.99751199573485,0 +Clustering,20.0,79.98933712457793,0 +Clustering,22.0,77.9989337124578,0 +Clustering,24.0,75.99075884130087,0 +Clustering,26.0,73.98258397014395,0 +Clustering,28.0,71.9921805580238,0 +Clustering,30.0,69.9840056868669,0 +Clustering,32.0,67.99360227474676,0 +Clustering,34.0,65.98542740358984,0 +Clustering,36.0,63.9950239914697,0 +Clustering,38.0,61.98684912031278,0 +Clustering,40.0,59.996445708192645,0 +Clustering,42.0,57.988270837035714,0 +Clustering,44.0,55.99786742491558,0 +Clustering,46.0,53.98969255375866,0 +Clustering,48.0,51.99928914163853,0 +Clustering,50.0,49.99111427048161,0 +Clustering,52.0,47.982939399324685,0 +Clustering,54.0,45.99253598720455,0 +Clustering,56.0,43.98436111604763,0 +Clustering,58.0,41.99395770392749,0 +Clustering,60.0,39.985782832770575,0 +Clustering,62.0,37.99537942065044,0 +Clustering,64.0,35.98720454949351,0 +Clustering,66.0,33.99680113737338,0 +Clustering,68.0,31.988626266216457,0 +Clustering,70.0,29.998222854096323,0 +Clustering,72.0,27.990047982939398,0 +Clustering,74.0,25.999644570819264,0 +Clustering,76.0,23.991469699662343,0 +Clustering,78.0,21.986315976541675,0 +Clustering,80.0,19.99982228540964,0 +Clustering,82.0,17.998933712457802,0 +Clustering,84.0,15.998045139505962,0 +Clustering,86.0,13.997156566554125,0 +Clustering,88.0,11.996267993602286,0 +Clustering,90.0,9.995379420650442,0 +Clustering,92.0,7.994490847698597,0 +Clustering,94.0,6.290563355251466,0 +Clustering,96.0,6.290563355251466,0 +Clustering,98.0,6.290563355251466,0 +Clustering,100.0,6.290563355251466,0 +Clustering,102.0,6.290563355251466,0 +Clustering,104.0,6.290563355251466,0 +Clustering,106.0,6.052958947929621,0 +Clustering,108.0,5.956282210769501,0 +FGD-Full,2.0,97.86742491558556,0 +FGD-Full,4.0,95.87702150346543,0 +FGD-Full,6.0,93.8866180913453,0 +FGD-Full,8.0,91.9850719744091,0 +FGD-Full,10.0,89.99466856228896,0 +FGD-Full,12.0,87.98649369113204,0 +FGD-Full,14.0,85.99609027901191,0 +FGD-Full,16.0,83.98791540785498,0 +FGD-Full,18.0,81.99751199573485,0 +FGD-Full,20.0,79.98933712457793,0 +FGD-Full,22.0,77.9989337124578,0 +FGD-Full,24.0,75.99075884130087,0 +FGD-Full,26.0,73.98258397014395,0 +FGD-Full,28.0,71.9921805580238,0 +FGD-Full,30.0,69.9840056868669,0 +FGD-Full,32.0,67.99360227474676,0 +FGD-Full,34.0,65.98542740358984,0 +FGD-Full,36.0,63.9950239914697,0 +FGD-Full,38.0,61.98684912031278,0 +FGD-Full,40.0,59.996445708192645,0 +FGD-Full,42.0,57.988270837035714,0 +FGD-Full,44.0,55.99786742491558,0 +FGD-Full,46.0,53.98969255375866,0 +FGD-Full,48.0,51.99928914163853,0 +FGD-Full,50.0,49.99111427048161,0 +FGD-Full,52.0,47.982939399324685,0 +FGD-Full,54.0,45.99253598720455,0 +FGD-Full,56.0,43.98436111604763,0 +FGD-Full,58.0,41.99395770392749,0 +FGD-Full,60.0,39.985782832770575,0 +FGD-Full,62.0,37.99537942065044,0 +FGD-Full,64.0,35.98720454949351,0 +FGD-Full,66.0,33.99680113737338,0 +FGD-Full,68.0,31.988626266216457,0 +FGD-Full,70.0,29.998222854096323,0 +FGD-Full,72.0,27.990047982939398,0 +FGD-Full,74.0,25.999644570819264,0 +FGD-Full,76.0,23.991469699662343,0 +FGD-Full,78.0,21.986315976541675,0 +FGD-Full,80.0,19.99982228540963,0 +FGD-Full,82.0,17.998933712457784,0 +FGD-Full,84.0,15.998045139505937,0 +FGD-Full,86.0,13.997156566554095,0 +FGD-Full,88.0,11.996267993602249,0 +FGD-Full,90.0,9.995379420650403,0 +FGD-Full,92.0,7.994490847698563,0 +FGD-Full,94.0,6.036431491025376,0 +FGD-Full,96.0,5.955571352407995,0 +FGD-Full,98.0,5.955571352407995,0 +FGD-Full,100.0,5.955571352407995,0 +FGD-Full,102.0,5.955571352407995,0 +FGD-Full,104.0,5.955571352407995,0 +FGD-Full,106.0,5.955571352407995,0 +FGD-Full,108.0,5.84183401457256,0 +FGD-2000,2.0,97.86742491558556,0 +FGD-2000,4.0,95.87702150346543,0 +FGD-2000,6.0,93.8866180913453,0 +FGD-2000,8.0,91.9850719744091,0 +FGD-2000,10.0,89.99466856228896,0 +FGD-2000,12.0,87.98649369113204,0 +FGD-2000,14.0,85.99609027901191,0 +FGD-2000,16.0,83.98791540785498,0 +FGD-2000,18.0,81.99751199573485,0 +FGD-2000,20.0,79.98933712457793,0 +FGD-2000,22.0,77.9989337124578,0 +FGD-2000,24.0,75.99075884130087,0 +FGD-2000,26.0,73.98258397014395,0 +FGD-2000,28.0,71.9921805580238,0 +FGD-2000,30.0,69.9840056868669,0 +FGD-2000,32.0,67.99360227474676,0 +FGD-2000,34.0,65.98542740358984,0 +FGD-2000,36.0,63.9950239914697,0 +FGD-2000,38.0,61.98684912031278,0 +FGD-2000,40.0,59.996445708192645,0 +FGD-2000,42.0,57.988270837035714,0 +FGD-2000,44.0,55.99786742491558,0 +FGD-2000,46.0,53.98969255375866,0 +FGD-2000,48.0,51.99928914163853,0 +FGD-2000,50.0,49.99111427048161,0 +FGD-2000,52.0,47.982939399324685,0 +FGD-2000,54.0,45.99253598720455,0 +FGD-2000,56.0,43.98436111604763,0 +FGD-2000,58.0,41.99395770392749,0 +FGD-2000,60.0,39.985782832770575,0 +FGD-2000,62.0,37.99537942065044,0 +FGD-2000,64.0,35.98720454949351,0 +FGD-2000,66.0,33.99680113737338,0 +FGD-2000,68.0,31.988626266216457,0 +FGD-2000,70.0,29.998222854096323,0 +FGD-2000,72.0,27.990047982939398,0 +FGD-2000,74.0,25.999644570819264,0 +FGD-2000,76.0,23.991469699662343,0 +FGD-2000,78.0,21.986315976541675,0 +FGD-2000,80.0,19.99982228540963,0 +FGD-2000,82.0,17.998933712457784,0 +FGD-2000,84.0,15.998045139505942,0 +FGD-2000,86.0,13.997156566554104,0 +FGD-2000,88.0,11.996267993602258,0 +FGD-2000,90.0,9.995379420650412,0 +FGD-2000,92.0,7.994490847698565,0 +FGD-2000,94.0,6.371423493868816,0 +FGD-2000,96.0,6.0188377465789635,0 +FGD-2000,98.0,5.175404300693065,0 +FGD-2000,100.0,5.175404300693065,0 +FGD-2000,102.0,5.175404300693065,0 +FGD-2000,104.0,5.175404300693065,0 +FGD-2000,106.0,5.15567798116223,0 +FGD-2000,108.0,4.928736449262459,0 diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-descending-90/figure9b_occupied.csv new file mode 100644 index 0000000..acc69d1 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-descending-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,15,0 +Random,4.0,29,0 +Random,6.0,43,0 +Random,8.0,81,0 +Random,10.0,184,0 +Random,12.0,278,0 +Random,14.0,357,0 +Random,16.0,437,0 +Random,18.0,507,0 +Random,20.0,568,0 +Random,22.0,622,0 +Random,24.0,671,0 +Random,26.0,716,0 +Random,28.0,764,0 +Random,30.0,806,0 +Random,32.0,843,0 +Random,34.0,882,0 +Random,36.0,910,0 +Random,38.0,936,0 +Random,40.0,960,0 +Random,42.0,975,0 +Random,44.0,983,0 +Random,46.0,998,0 +Random,48.0,1020,0 +Random,50.0,1027,0 +Random,52.0,1036,0 +Random,54.0,1044,0 +Random,56.0,1051,0 +Random,58.0,1057,0 +Random,60.0,1066,0 +Random,62.0,1071,0 +Random,64.0,1077,0 +Random,66.0,1082,0 +Random,68.0,1085,0 +Random,70.0,1088,0 +Random,72.0,1091,0 +Random,74.0,1093,0 +Random,76.0,1095,0 +Random,78.0,1095,0 +Random,80.0,1096,0 +Random,82.0,1099,0 +Random,84.0,1099,0 +Random,86.0,1099,0 +Random,88.0,1099,0 +Random,90.0,1100,0 +Random,92.0,1100,0 +Random,94.0,1100,0 +Random,96.0,1100,0 +Random,98.0,1100,0 +Random,100.0,1100,0 +Random,102.0,1100,0 +Random,104.0,1100,0 +Random,106.0,1100,0 +Random,108.0,1100,0 +Clustering,2.0,15,0 +Clustering,4.0,29,0 +Clustering,6.0,43,0 +Clustering,8.0,80,0 +Clustering,10.0,136,0 +Clustering,12.0,192,0 +Clustering,14.0,250,0 +Clustering,16.0,352,0 +Clustering,18.0,408,0 +Clustering,20.0,465,0 +Clustering,22.0,521,0 +Clustering,24.0,565,0 +Clustering,26.0,581,0 +Clustering,28.0,595,0 +Clustering,30.0,609,0 +Clustering,32.0,623,0 +Clustering,34.0,637,0 +Clustering,36.0,651,0 +Clustering,38.0,665,0 +Clustering,40.0,679,0 +Clustering,42.0,693,0 +Clustering,44.0,707,0 +Clustering,46.0,721,0 +Clustering,48.0,735,0 +Clustering,50.0,750,0 +Clustering,52.0,764,0 +Clustering,54.0,778,0 +Clustering,56.0,792,0 +Clustering,58.0,806,0 +Clustering,60.0,836,0 +Clustering,62.0,850,0 +Clustering,64.0,864,0 +Clustering,66.0,877,0 +Clustering,68.0,892,0 +Clustering,70.0,906,0 +Clustering,72.0,920,0 +Clustering,74.0,934,0 +Clustering,76.0,948,0 +Clustering,78.0,962,0 +Clustering,80.0,980,0 +Clustering,82.0,997,0 +Clustering,84.0,1014,0 +Clustering,86.0,1032,0 +Clustering,88.0,1049,0 +Clustering,90.0,1067,0 +Clustering,92.0,1084,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,15,0 +FGD-Full,4.0,29,0 +FGD-Full,6.0,43,0 +FGD-Full,8.0,79,0 +FGD-Full,10.0,116,0 +FGD-Full,12.0,154,0 +FGD-Full,14.0,191,0 +FGD-Full,16.0,206,0 +FGD-Full,18.0,227,0 +FGD-Full,20.0,255,0 +FGD-Full,22.0,280,0 +FGD-Full,24.0,300,0 +FGD-Full,26.0,318,0 +FGD-Full,28.0,337,0 +FGD-Full,30.0,356,0 +FGD-Full,32.0,375,0 +FGD-Full,34.0,393,0 +FGD-Full,36.0,412,0 +FGD-Full,38.0,431,0 +FGD-Full,40.0,450,0 +FGD-Full,42.0,468,0 +FGD-Full,44.0,487,0 +FGD-Full,46.0,506,0 +FGD-Full,48.0,525,0 +FGD-Full,50.0,543,0 +FGD-Full,52.0,562,0 +FGD-Full,54.0,584,0 +FGD-Full,56.0,640,0 +FGD-Full,58.0,696,0 +FGD-Full,60.0,757,0 +FGD-Full,62.0,776,0 +FGD-Full,64.0,801,0 +FGD-Full,66.0,837,0 +FGD-Full,68.0,894,0 +FGD-Full,70.0,926,0 +FGD-Full,72.0,926,0 +FGD-Full,74.0,926,0 +FGD-Full,76.0,926,0 +FGD-Full,78.0,926,0 +FGD-Full,80.0,926,0 +FGD-Full,82.0,926,0 +FGD-Full,84.0,958,0 +FGD-Full,86.0,1027,0 +FGD-Full,88.0,1075,0 +FGD-Full,90.0,1092,0 +FGD-Full,92.0,1100,0 +FGD-Full,94.0,1100,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,15,0 +FGD-2000,4.0,29,0 +FGD-2000,6.0,43,0 +FGD-2000,8.0,79,0 +FGD-2000,10.0,119,0 +FGD-2000,12.0,154,0 +FGD-2000,14.0,191,0 +FGD-2000,16.0,206,0 +FGD-2000,18.0,228,0 +FGD-2000,20.0,257,0 +FGD-2000,22.0,282,0 +FGD-2000,24.0,301,0 +FGD-2000,26.0,320,0 +FGD-2000,28.0,338,0 +FGD-2000,30.0,357,0 +FGD-2000,32.0,376,0 +FGD-2000,34.0,395,0 +FGD-2000,36.0,413,0 +FGD-2000,38.0,432,0 +FGD-2000,40.0,451,0 +FGD-2000,42.0,470,0 +FGD-2000,44.0,488,0 +FGD-2000,46.0,507,0 +FGD-2000,48.0,526,0 +FGD-2000,50.0,545,0 +FGD-2000,52.0,563,0 +FGD-2000,54.0,587,0 +FGD-2000,56.0,644,0 +FGD-2000,58.0,700,0 +FGD-2000,60.0,762,0 +FGD-2000,62.0,798,0 +FGD-2000,64.0,854,0 +FGD-2000,66.0,904,0 +FGD-2000,68.0,904,0 +FGD-2000,70.0,904,0 +FGD-2000,72.0,938,0 +FGD-2000,74.0,978,0 +FGD-2000,76.0,992,0 +FGD-2000,78.0,1005,0 +FGD-2000,80.0,1005,0 +FGD-2000,82.0,1005,0 +FGD-2000,84.0,1055,0 +FGD-2000,86.0,1100,0 +FGD-2000,88.0,1100,0 +FGD-2000,90.0,1100,0 +FGD-2000,92.0,1100,0 +FGD-2000,94.0,1100,0 +FGD-2000,96.0,1100,0 +FGD-2000,98.0,1100,0 +FGD-2000,100.0,1100,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-descending-90/figure9c_failed.csv new file mode 100644 index 0000000..5f6ac58 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-descending-90/figure9c_failed.csv @@ -0,0 +1,5 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,<1,107.59000000000026,0 +Clustering,<1,129.04000000000045,0 +FGD-Full,<1,110.19000000000028,0 +FGD-2000,<1,113.75000000000034,0 diff --git a/standalone_fgd_replication/result/dist-shift-descending-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-descending-90/figure9d_breakdown.csv new file mode 100644 index 0000000..bf8c831 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-descending-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,61.32578162923633,0 +Random,stranded,25.221459586485977,0 +Random,non_gpu,13.452758784277686,0 +Clustering,deficient,53.260820457360815,0 +Clustering,stranded,33.25901907168417,0 +Clustering,non_gpu,13.480160470955017,0 +FGD-Full,deficient,51.44119635093666,0 +FGD-Full,stranded,35.09379965803255,0 +FGD-Full,non_gpu,13.465003991030805,0 +FGD-2000,deficient,75.59290005750061,0 +FGD-2000,stranded,11.026356632008742,0 +FGD-2000,non_gpu,13.380743310490645,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-phased-01234-90/experiment_summary.log new file mode 100644 index 0000000..aeb35af --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-01234-90/experiment_summary.log @@ -0,0 +1,29 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-phased-01234-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: phased +Tier order: [0, 1, 2, 3, 4] + Phase 0: Tier 0 - 1088 tasks (gpu range: 0.00-0.00) + Phase 1: Tier 1 - 1600 tasks (gpu range: 0.05-0.48) + Phase 2: Tier 2 - 1478 tasks (gpu range: 0.55-0.81) + Phase 3: Tier 3 - 3911 tasks (gpu range: 1.00-1.00) + Phase 4: Tier 4 - 75 tasks (gpu range: 2.00-8.00) +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 13 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 96.3 78.4 6847 1305 14.1 +Clustering 98.2 81.7 7032 1120 13.1 +FGD-Full 98.9 62.5 5950 2202 85.6 +FGD-2000 94.6 58.7 5740 2412 58.7 diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure7.png b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure7.png new file mode 100644 index 0000000..6ae8c23 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure7_results.csv new file mode 100644 index 0000000..479f791 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.87256834904882,13.87256834904882,0 +Random,2.0,18.529727482757675,18.15863898266317,0 +Random,4.0,20.01767452941333,19.216825250923673,0 +Random,6.0,21.372379668128684,20.08901137844258,0 +Random,8.0,22.752061000076978,20.931289614090755,0 +Random,10.0,23.607905307387295,21.245730271805627,0 +Random,12.0,24.413832299443982,21.48187291558136,0 +Random,14.0,25.049231561160084,21.540068819495488,0 +Random,16.0,25.815474099366888,21.683300762498455,0 +Random,18.0,26.584481335057742,21.798849494228442,0 +Random,20.0,27.45996325303813,21.966262589788176,0 +Random,22.0,28.369057862985898,22.127209725714394,0 +Random,24.0,29.44144455569628,22.372672488229306,0 +Random,26.0,30.41929325304767,22.507249674001038,0 +Random,28.0,31.409997491771964,22.611458244134564,0 +Random,30.0,32.601036901528424,22.81835042230331,0 +Random,32.0,33.58581866393122,22.837401701072277,0 +Random,34.0,34.53139947139237,22.78691887634161,0 +Random,36.0,35.462375008952016,22.69541583121345,0 +Random,38.0,36.530834870222066,22.64561190586613,0 +Random,40.0,37.67001304149824,22.59531331396214,0 +Random,42.0,38.844591092062906,22.526687338123292,0 +Random,44.0,40.208459045141396,22.51016308583695,0 +Random,46.0,41.71783489610783,22.524813574081197,0 +Random,48.0,43.22178972153204,22.468878495366198,0 +Random,50.0,44.72937940330948,22.362304982653338,0 +Random,52.0,46.36177487743272,22.24739017665611,0 +Random,54.0,48.64414264550416,22.374403766677457,0 +Random,56.0,50.55239214420225,22.23694349303884,0 +Random,58.0,53.19057833874755,22.338719518416276,0 +Random,60.0,56.00810933259994,22.39727165811563,0 +Random,62.0,58.98382313308399,22.41322385341401,0 +Random,64.0,62.20257368782396,22.38717828906728,0 +Random,66.0,65.59234207776345,22.289972724560116,0 +Random,68.0,69.68868032218433,22.294928437177315,0 +Random,70.0,74.1750706613464,22.240657405335735,0 +Random,72.0,79.71496687680163,22.315090780938053,0 +Random,74.0,85.37313794705426,22.18457478339848,0 +Random,76.0,90.40974913415822,22.031250757554346,0 +Random,78.0,91.67958934835083,21.868197054088668,0 +Random,80.0,92.78470824490502,21.802015504072124,0 +Random,82.0,93.89012853604267,21.611248352564942,0 +Random,84.0,94.60254439700026,21.42217204028045,0 +Random,86.0,95.20421218358118,21.287709217946016,0 +Random,88.0,95.83163849526318,21.12144980661556,0 +Random,90.0,96.27843500534591,20.877722835173877,0 +Random,92.0,96.2708044968471,20.82474199992227,0 +Random,94.0,96.2708044968471,20.82474199992227,0 +Random,96.0,96.2708044968471,20.82474199992227,0 +Random,98.0,96.26825262860443,20.807081721505067,0 +Random,100.0,96.26313628199767,20.771761164670675,0 +Random,102.0,96.26313628199767,20.771761164670675,0 +Random,104.0,96.26313628199767,20.771761164670675,0 +Random,106.0,96.26313628199767,20.771761164670675,0 +Random,108.0,96.26313628199767,20.771761164670675,0 +Clustering,0.0,13.87256834904882,13.87256834904882,0 +Clustering,2.0,22.17164840073194,21.727624398905306,0 +Clustering,4.0,22.65951113497765,21.752969612548988,0 +Clustering,6.0,22.97381733076725,21.59428593963648,0 +Clustering,8.0,24.421184979710798,22.466839181201205,0 +Clustering,10.0,25.6058745935413,23.04378545680744,0 +Clustering,12.0,25.612209221821047,22.536331733669307,0 +Clustering,14.0,26.113218950973287,22.455001540832413,0 +Clustering,16.0,27.049523910468555,22.719821459620874,0 +Clustering,18.0,27.987204254181915,22.949059852320605,0 +Clustering,20.0,29.030878893906493,23.22289739136246,0 +Clustering,22.0,30.04692917557017,23.435910585842404,0 +Clustering,24.0,31.18038941733255,23.69410370370103,0 +Clustering,26.0,32.362410745310335,23.94496323889106,0 +Clustering,28.0,33.5901297087501,24.180893854685205,0 +Clustering,30.0,34.94977642345804,24.462296951488405,0 +Clustering,32.0,35.92229341071718,24.42613809278232,0 +Clustering,34.0,36.584283840785616,24.141596367088177,0 +Clustering,36.0,37.40100705990807,23.936112781969246,0 +Clustering,38.0,38.22730365754623,23.697259750889067,0 +Clustering,40.0,39.135063431562436,23.47408318717071,0 +Clustering,42.0,40.11401003211579,23.262846549991163,0 +Clustering,44.0,41.08112635059244,22.998714098033822,0 +Clustering,46.0,42.04492748178892,22.70142148128152,0 +Clustering,48.0,43.22406471422813,22.470061151956664,0 +Clustering,50.0,44.396386978839274,22.195826523701918,0 +Clustering,52.0,45.66100390266556,21.911114757060172,0 +Clustering,54.0,47.031608369955855,21.632701045516228,0 +Clustering,56.0,48.65120711887793,21.400651832352363,0 +Clustering,58.0,50.26611666338836,21.110518375496625,0 +Clustering,60.0,52.15017884355066,20.85451082881776,0 +Clustering,62.0,54.17952676620549,20.58764246161372,0 +Clustering,64.0,56.644244128494734,20.386693301764232,0 +Clustering,66.0,59.134273944104486,20.095354298190227,0 +Clustering,68.0,62.02413053767059,19.84287183115592,0 +Clustering,70.0,65.2821909734479,19.57421585398988,0 +Clustering,72.0,68.9138704943796,19.291474818330634,0 +Clustering,74.0,73.2644189009551,19.038072386169585,0 +Clustering,76.0,78.35594577708711,18.801527987954977,0 +Clustering,78.0,84.22288453588048,18.517958547679225,0 +Clustering,80.0,91.27777632902291,18.252310987278516,0 +Clustering,82.0,98.21498691907522,18.033716809096877,0 +Clustering,84.0,98.21498691907522,18.033716809096877,0 +Clustering,86.0,98.21386368740066,18.016056530679673,0 +Clustering,88.0,98.21386368740066,18.016056530679673,0 +Clustering,90.0,98.21386368740066,18.016056530679673,0 +Clustering,92.0,98.21386368740066,18.016056530679673,0 +Clustering,94.0,98.21386368740066,18.016056530679673,0 +Clustering,96.0,98.21386368740066,18.016056530679673,0 +Clustering,98.0,98.21273827723174,17.998396252262474,0 +Clustering,100.0,98.21048089601071,17.96307569542808,0 +Clustering,102.0,98.21048089601071,17.96307569542808,0 +Clustering,104.0,98.21048089601071,17.96307569542808,0 +Clustering,106.0,98.21048089601071,17.96307569542808,0 +Clustering,108.0,98.21048089601071,17.96307569542808,0 +FGD-Full,0.0,13.87256834904882,13.87256834904882,0 +FGD-Full,2.0,14.608215093124393,14.315661377317715,0 +FGD-Full,4.0,15.086601183328074,14.483029891628977,0 +FGD-Full,6.0,15.531892929243524,14.599234087611729,0 +FGD-Full,8.0,16.04942856140675,14.765046443850835,0 +FGD-Full,10.0,16.43581144524881,14.79126640916946,0 +FGD-Full,12.0,16.983937454488533,14.94426526440149,0 +FGD-Full,14.0,17.599844797399985,15.134271373667533,0 +FGD-Full,16.0,18.351983347290325,15.414459288098751,0 +FGD-Full,18.0,19.080960732865943,15.646082614089218,0 +FGD-Full,20.0,19.906968841661367,15.924336857744473,0 +FGD-Full,22.0,20.709841163925617,16.153197650539898,0 +FGD-Full,24.0,21.59912368119408,16.413261218822147,0 +FGD-Full,26.0,22.52206682940975,16.664088053829936,0 +FGD-Full,28.0,23.47712073002142,16.900731533596723,0 +FGD-Full,30.0,24.547493214541625,17.181456646621637,0 +FGD-Full,32.0,25.14934371324128,17.100838620153493,0 +FGD-Full,34.0,25.481652128094765,16.815082758493233,0 +FGD-Full,36.0,25.836557813244536,16.535029677813426,0 +FGD-Full,38.0,26.217785510032254,16.25251100339336,0 +FGD-Full,40.0,26.62442352850949,15.96992256858453,0 +FGD-Full,42.0,27.052226176837298,15.688079697930583,0 +FGD-Full,44.0,27.53634428961916,15.415850680852708,0 +FGD-Full,46.0,28.04769953627448,15.143863645123343,0 +FGD-Full,48.0,28.95955458855255,15.054645296327319,0 +FGD-Full,50.0,31.407698445517063,15.702174740879418,0 +FGD-Full,52.0,34.63619267034999,16.620694410605818,0 +FGD-Full,54.0,39.19900275493537,18.03000869563243,0 +FGD-Full,56.0,46.15853074927199,20.328784592650756,0 +FGD-Full,58.0,59.19338541480417,24.94390536619579,0 +FGD-Full,60.0,73.67703356427852,29.85576185058965,0 +FGD-Full,62.0,90.43977285267391,35.2179900968152,0 +FGD-Full,64.0,95.66930899515359,36.71035578147072,0 +FGD-Full,66.0,98.11751234574261,37.126676254941415,0 +FGD-Full,68.0,98.86539427500726,37.23396899726241,0 +FGD-Full,70.0,98.86515398023879,37.21630871884521,0 +FGD-Full,72.0,98.8646727094011,37.18098816201081,0 +FGD-Full,74.0,98.8646727094011,37.18098816201081,0 +FGD-Full,76.0,98.8646727094011,37.18098816201081,0 +FGD-Full,78.0,98.86443173268772,37.163327883593624,0 +FGD-Full,80.0,98.86443173268772,37.163327883593624,0 +FGD-Full,82.0,98.86443173268772,37.163327883593624,0 +FGD-Full,84.0,98.86443173268772,37.163327883593624,0 +FGD-Full,86.0,98.86419052801412,37.14566760517642,0 +FGD-Full,88.0,98.86419052801412,37.14566760517642,0 +FGD-Full,90.0,98.86419052801412,37.14566760517642,0 +FGD-Full,92.0,98.86419052801412,37.14566760517642,0 +FGD-Full,94.0,98.86419052801412,37.14566760517642,0 +FGD-Full,96.0,98.86419052801412,37.14566760517642,0 +FGD-Full,98.0,98.86394909505673,37.128007326759224,0 +FGD-Full,100.0,98.86346554299298,37.092686769924825,0 +FGD-Full,102.0,98.86346554299298,37.092686769924825,0 +FGD-Full,104.0,98.86346554299298,37.092686769924825,0 +FGD-Full,106.0,98.86346554299298,37.092686769924825,0 +FGD-Full,108.0,98.86346554299298,37.092686769924825,0 +FGD-2000,0.0,13.87256834904882,13.87256834904882,0 +FGD-2000,2.0,18.59068686308104,18.21837755037434,0 +FGD-2000,4.0,21.415407412080782,20.558638882383313,0 +FGD-2000,6.0,22.78529811459714,21.417086922142683,0 +FGD-2000,8.0,24.328782321529737,22.381831198869694,0 +FGD-2000,10.0,25.763473556996765,23.18561528139772,0 +FGD-2000,12.0,26.604482606167874,23.40943885092174,0 +FGD-2000,14.0,27.27722749947801,23.45594339328226,0 +FGD-2000,16.0,28.210179580226562,23.69469590400226,0 +FGD-2000,18.0,29.159122472271555,23.910014047127177,0 +FGD-2000,20.0,30.232325825969692,24.183980206885753,0 +FGD-2000,22.0,31.282595598763336,24.39970184845929,0 +FGD-2000,24.0,32.44860990173475,24.657829565953403,0 +FGD-2000,26.0,33.66487691252304,24.9086585809733,0 +FGD-2000,28.0,34.92980406906734,25.14529988072791,0 +FGD-2000,30.0,36.3070475785065,25.41228786519853,0 +FGD-2000,32.0,37.285522334030865,25.35309499812849,0 +FGD-2000,34.0,38.004766592980545,25.078958470420375,0 +FGD-2000,36.0,38.74915045764452,24.798905389740455,0 +FGD-2000,38.0,39.54868070841898,24.51638671532027,0 +FGD-2000,40.0,40.40163039951326,24.23379828051133,0 +FGD-2000,42.0,41.302296240275425,23.951955409857273,0 +FGD-2000,44.0,42.272551942898964,23.66571763471129,0 +FGD-2000,46.0,43.31306680541239,23.386131076631244,0 +FGD-2000,48.0,44.463406174252135,23.11433370195885,0 +FGD-2000,50.0,45.69833409775615,22.846730670660694,0 +FGD-2000,52.0,47.21372224787641,22.706553251679978,0 +FGD-2000,54.0,50.68868997454299,23.576051075417453,0 +FGD-2000,56.0,60.99247543644879,27.403798897890503,0 +FGD-2000,58.0,77.3372484574459,33.46928513303221,0 +FGD-2000,60.0,93.82702498534145,39.121550741177956,0 +FGD-2000,62.0,94.58578715751086,39.18578052631768,0 +FGD-2000,64.0,94.58373214099038,39.16812024790048,0 +FGD-2000,66.0,94.58373214099038,39.16812024790048,0 +FGD-2000,68.0,94.58167535990135,39.150459969483286,0 +FGD-2000,70.0,94.57961681197003,39.13279969106608,0 +FGD-2000,72.0,94.57549440646609,39.09747913423168,0 +FGD-2000,74.0,94.57549440646609,39.09747913423168,0 +FGD-2000,76.0,94.57549440646609,39.09747913423168,0 +FGD-2000,78.0,94.57343054432646,39.07981885581448,0 +FGD-2000,80.0,94.57343054432646,39.07981885581448,0 +FGD-2000,82.0,94.57343054432646,39.07981885581448,0 +FGD-2000,84.0,94.57343054432646,39.07981885581448,0 +FGD-2000,86.0,94.57136490621045,39.062158577397284,0 +FGD-2000,88.0,94.57136490621045,39.062158577397284,0 +FGD-2000,90.0,94.57136490621045,39.062158577397284,0 +FGD-2000,92.0,94.57136490621045,39.062158577397284,0 +FGD-2000,94.0,94.57136490621045,39.062158577397284,0 +FGD-2000,96.0,94.57136490621045,39.062158577397284,0 +FGD-2000,98.0,94.56929748982469,39.04449829898008,0 +FGD-2000,100.0,94.5651573130508,39.00917774214568,0 +FGD-2000,102.0,94.5651573130508,39.00917774214568,0 +FGD-2000,104.0,94.5651573130508,39.00917774214568,0 +FGD-2000,106.0,94.5651573130508,39.00917774214568,0 +FGD-2000,108.0,94.5651573130508,39.00917774214568,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9.png b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9.png new file mode 100644 index 0000000..c70bf21 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9a_unalloc.csv new file mode 100644 index 0000000..d3f0c75 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.99733428114466,0 +Random,4.0,95.99928914163871,0 +Random,6.0,93.99520170606031,0 +Random,8.0,91.99733428114462,0 +Random,10.0,89.99413541851803,0 +Random,12.0,87.99058112671071,0 +Random,14.0,85.99093655589137,0 +Random,16.0,83.99342456015646,0 +Random,18.0,81.99840056868688,0 +Random,20.0,79.99377998933726,0 +Random,22.0,77.99768971032536,0 +Random,24.0,75.99040341212022,0 +Random,26.0,73.99004798293947,0 +Random,28.0,71.98809312244539,0 +Random,30.0,69.99271370179495,0 +Random,32.0,67.99715656655415,0 +Random,34.0,65.98898169539724,0 +Random,36.0,63.9985782832771,0 +Random,38.0,61.99040341212017,0 +Random,40.0,59.98222854096327,0 +Random,42.0,57.99182512884311,0 +Random,44.0,55.98365025768619,0 +Random,46.0,53.99324684556605,0 +Random,48.0,51.98507197440914,0 +Random,50.0,49.99466856228901,0 +Random,52.0,47.98649369113209,0 +Random,54.0,45.996090279011966,0 +Random,56.0,43.98791540785504,0 +Random,58.0,41.997511995734904,0 +Random,60.0,39.989337124578014,0 +Random,62.0,37.99893371245793,0 +Random,64.0,35.990758841301016,0 +Random,66.0,33.98258397014409,0 +Random,68.0,31.992180558023954,0 +Random,70.0,29.984005686867015,0 +Random,72.0,27.99360227474687,0 +Random,74.0,25.985427403589938,0 +Random,76.0,24.36822463124233,0 +Random,78.0,23.85285231917549,0 +Random,80.0,23.497423138439743,0 +Random,82.0,23.017593744446504,0 +Random,84.0,22.644393104673963,0 +Random,86.0,22.360049760085378,0 +Random,88.0,22.040163497423205,0 +Random,90.0,21.684734316687457,0 +Random,92.0,21.631419939577096,0 +Random,94.0,21.631419939577096,0 +Random,96.0,21.631419939577096,0 +Random,98.0,21.61364848054031,0 +Random,100.0,21.57810556246674,0 +Random,102.0,21.57810556246674,0 +Random,104.0,21.57810556246674,0 +Random,106.0,21.57810556246674,0 +Random,108.0,21.57810556246674,0 +Clustering,2.0,97.9973342811445,0 +Clustering,4.0,95.99928914163861,0 +Clustering,6.0,93.99520170606016,0 +Clustering,8.0,91.99733428114456,0 +Clustering,10.0,89.99413541851796,0 +Clustering,12.0,87.99058112671061,0 +Clustering,14.0,85.99093655589127,0 +Clustering,16.0,83.99342456015641,0 +Clustering,18.0,81.99840056868668,0 +Clustering,20.0,79.99377998933711,0 +Clustering,22.0,77.99768971032523,0 +Clustering,24.0,75.99040341212016,0 +Clustering,26.0,73.99004798293942,0 +Clustering,28.0,71.98809312244536,0 +Clustering,30.0,69.99271370179491,0 +Clustering,32.0,67.99715656655412,0 +Clustering,34.0,65.98898169539721,0 +Clustering,36.0,63.99857828327708,0 +Clustering,38.0,61.990403412120145,0 +Clustering,40.0,59.98222854096322,0 +Clustering,42.0,57.99182512884309,0 +Clustering,44.0,55.983650257686165,0 +Clustering,46.0,53.993246845566034,0 +Clustering,48.0,51.98507197440912,0 +Clustering,50.0,49.99466856228897,0 +Clustering,52.0,47.986493691132054,0 +Clustering,54.0,45.99609027901194,0 +Clustering,56.0,43.98791540785502,0 +Clustering,58.0,41.9975119957349,0 +Clustering,60.0,39.989337124577865,0 +Clustering,62.0,37.998933712457735,0 +Clustering,64.0,35.99075884130081,0 +Clustering,66.0,33.982583970143885,0 +Clustering,68.0,31.992180558023755,0 +Clustering,70.0,29.984005686866833,0 +Clustering,72.0,27.993602274746692,0 +Clustering,74.0,25.98542740358976,0 +Clustering,76.0,23.995023991469616,0 +Clustering,78.0,21.98684912031271,0 +Clustering,80.0,19.99644570819257,0 +Clustering,82.0,18.361471476808173,0 +Clustering,84.0,18.361471476808173,0 +Clustering,86.0,18.343700017771383,0 +Clustering,88.0,18.343700017771383,0 +Clustering,90.0,18.343700017771383,0 +Clustering,92.0,18.343700017771383,0 +Clustering,94.0,18.343700017771383,0 +Clustering,96.0,18.343700017771383,0 +Clustering,98.0,18.325928558734596,0 +Clustering,100.0,18.29038564066102,0 +Clustering,102.0,18.29038564066102,0 +Clustering,104.0,18.29038564066102,0 +Clustering,106.0,18.29038564066102,0 +Clustering,108.0,18.29038564066102,0 +FGD-Full,2.0,97.99733428114449,0 +FGD-Full,4.0,95.99928914163851,0 +FGD-Full,6.0,93.99520170606004,0 +FGD-Full,8.0,91.99733428114443,0 +FGD-Full,10.0,89.99413541851779,0 +FGD-Full,12.0,87.99058112671044,0 +FGD-Full,14.0,85.99093655589117,0 +FGD-Full,16.0,83.99342456015631,0 +FGD-Full,18.0,81.99840056868662,0 +FGD-Full,20.0,79.99377998933706,0 +FGD-Full,22.0,77.99768971032516,0 +FGD-Full,24.0,75.9904034121201,0 +FGD-Full,26.0,73.99004798293933,0 +FGD-Full,28.0,71.98809312244528,0 +FGD-Full,30.0,69.99271370179486,0 +FGD-Full,32.0,67.99715656655407,0 +FGD-Full,34.0,65.98898169539714,0 +FGD-Full,36.0,63.998578283277006,0 +FGD-Full,38.0,61.99040341212009,0 +FGD-Full,40.0,59.982228540963156,0 +FGD-Full,42.0,57.99182512884302,0 +FGD-Full,44.0,55.9836502576861,0 +FGD-Full,46.0,53.99324684556597,0 +FGD-Full,48.0,51.98507197440904,0 +FGD-Full,50.0,49.9946685622889,0 +FGD-Full,52.0,47.98649369113198,0 +FGD-Full,54.0,45.99609027901189,0 +FGD-Full,56.0,44.04122978496534,0 +FGD-Full,58.0,42.139683668029164,0 +FGD-Full,60.0,40.522480895681554,0 +FGD-Full,62.0,38.94082104140752,0 +FGD-Full,64.0,38.37213435223034,0 +FGD-Full,66.0,37.838990581126744,0 +FGD-Full,68.0,37.66127599075888,0 +FGD-Full,70.0,37.6435045317221,0 +FGD-Full,72.0,37.60796161364853,0 +FGD-Full,74.0,37.60796161364853,0 +FGD-Full,76.0,37.60796161364853,0 +FGD-Full,78.0,37.59019015461174,0 +FGD-Full,80.0,37.59019015461174,0 +FGD-Full,82.0,37.59019015461174,0 +FGD-Full,84.0,37.59019015461174,0 +FGD-Full,86.0,37.57241869557495,0 +FGD-Full,88.0,37.57241869557495,0 +FGD-Full,90.0,37.57241869557495,0 +FGD-Full,92.0,37.57241869557495,0 +FGD-Full,94.0,37.57241869557495,0 +FGD-Full,96.0,37.57241869557495,0 +FGD-Full,98.0,37.554647236538166,0 +FGD-Full,100.0,37.519104318464585,0 +FGD-Full,102.0,37.519104318464585,0 +FGD-Full,104.0,37.519104318464585,0 +FGD-Full,106.0,37.519104318464585,0 +FGD-Full,108.0,37.519104318464585,0 +FGD-2000,2.0,97.99733428114448,0 +FGD-2000,4.0,95.99928914163851,0 +FGD-2000,6.0,93.99520170606009,0 +FGD-2000,8.0,91.99733428114449,0 +FGD-2000,10.0,89.99413541851791,0 +FGD-2000,12.0,87.99058112671057,0 +FGD-2000,14.0,85.99093655589127,0 +FGD-2000,16.0,83.99342456015646,0 +FGD-2000,18.0,81.99840056868673,0 +FGD-2000,20.0,79.99377998933716,0 +FGD-2000,22.0,77.99768971032526,0 +FGD-2000,24.0,75.99040341212016,0 +FGD-2000,26.0,73.99004798293943,0 +FGD-2000,28.0,71.98809312244538,0 +FGD-2000,30.0,69.99271370179495,0 +FGD-2000,32.0,67.99715656655417,0 +FGD-2000,34.0,65.98898169539724,0 +FGD-2000,36.0,63.998578283277105,0 +FGD-2000,38.0,61.99040341212017,0 +FGD-2000,40.0,59.982228540963256,0 +FGD-2000,42.0,57.991825128843125,0 +FGD-2000,44.0,55.9836502576862,0 +FGD-2000,46.0,53.99324684556607,0 +FGD-2000,48.0,51.985071974409145,0 +FGD-2000,50.0,49.99466856228901,0 +FGD-2000,52.0,48.0931224453528,0 +FGD-2000,54.0,46.51146259107877,0 +FGD-2000,56.0,44.929802736804696,0 +FGD-2000,58.0,43.27705704638351,0 +FGD-2000,60.0,41.69539719210952,0 +FGD-2000,62.0,41.42882530655771,0 +FGD-2000,64.0,41.41105384752093,0 +FGD-2000,66.0,41.41105384752093,0 +FGD-2000,68.0,41.39328238848414,0 +FGD-2000,70.0,41.37551092944735,0 +FGD-2000,72.0,41.33996801137378,0 +FGD-2000,74.0,41.33996801137378,0 +FGD-2000,76.0,41.33996801137378,0 +FGD-2000,78.0,41.32219655233698,0 +FGD-2000,80.0,41.32219655233698,0 +FGD-2000,82.0,41.32219655233698,0 +FGD-2000,84.0,41.32219655233698,0 +FGD-2000,86.0,41.304425093300196,0 +FGD-2000,88.0,41.304425093300196,0 +FGD-2000,90.0,41.304425093300196,0 +FGD-2000,92.0,41.304425093300196,0 +FGD-2000,94.0,41.304425093300196,0 +FGD-2000,96.0,41.304425093300196,0 +FGD-2000,98.0,41.28665363426341,0 +FGD-2000,100.0,41.251110716189835,0 +FGD-2000,102.0,41.251110716189835,0 +FGD-2000,104.0,41.251110716189835,0 +FGD-2000,106.0,41.251110716189835,0 +FGD-2000,108.0,41.251110716189835,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9b_occupied.csv new file mode 100644 index 0000000..d3a3b31 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,820,0 +Random,4.0,887,0 +Random,6.0,942,0 +Random,8.0,993,0 +Random,10.0,1021,0 +Random,12.0,1042,0 +Random,14.0,1049,0 +Random,16.0,1058,0 +Random,18.0,1065,0 +Random,20.0,1071,0 +Random,22.0,1077,0 +Random,24.0,1081,0 +Random,26.0,1083,0 +Random,28.0,1089,0 +Random,30.0,1091,0 +Random,32.0,1092,0 +Random,34.0,1093,0 +Random,36.0,1093,0 +Random,38.0,1094,0 +Random,40.0,1094,0 +Random,42.0,1094,0 +Random,44.0,1094,0 +Random,46.0,1094,0 +Random,48.0,1094,0 +Random,50.0,1094,0 +Random,52.0,1094,0 +Random,54.0,1095,0 +Random,56.0,1097,0 +Random,58.0,1097,0 +Random,60.0,1097,0 +Random,62.0,1097,0 +Random,64.0,1097,0 +Random,66.0,1097,0 +Random,68.0,1097,0 +Random,70.0,1097,0 +Random,72.0,1097,0 +Random,74.0,1098,0 +Random,76.0,1098,0 +Random,78.0,1099,0 +Random,80.0,1099,0 +Random,82.0,1099,0 +Random,84.0,1100,0 +Random,86.0,1100,0 +Random,88.0,1100,0 +Random,90.0,1100,0 +Random,92.0,1100,0 +Random,94.0,1100,0 +Random,96.0,1100,0 +Random,98.0,1100,0 +Random,100.0,1100,0 +Random,102.0,1100,0 +Random,104.0,1100,0 +Random,106.0,1100,0 +Random,108.0,1100,0 +Clustering,2.0,359,0 +Clustering,4.0,414,0 +Clustering,6.0,474,0 +Clustering,8.0,530,0 +Clustering,10.0,557,0 +Clustering,12.0,569,0 +Clustering,14.0,585,0 +Clustering,16.0,604,0 +Clustering,18.0,622,0 +Clustering,20.0,641,0 +Clustering,22.0,659,0 +Clustering,24.0,678,0 +Clustering,26.0,696,0 +Clustering,28.0,714,0 +Clustering,30.0,733,0 +Clustering,32.0,749,0 +Clustering,34.0,763,0 +Clustering,36.0,778,0 +Clustering,38.0,792,0 +Clustering,40.0,807,0 +Clustering,42.0,821,0 +Clustering,44.0,835,0 +Clustering,46.0,849,0 +Clustering,48.0,863,0 +Clustering,50.0,877,0 +Clustering,52.0,891,0 +Clustering,54.0,905,0 +Clustering,56.0,920,0 +Clustering,58.0,934,0 +Clustering,60.0,948,0 +Clustering,62.0,962,0 +Clustering,64.0,976,0 +Clustering,66.0,990,0 +Clustering,68.0,1004,0 +Clustering,70.0,1019,0 +Clustering,72.0,1032,0 +Clustering,74.0,1047,0 +Clustering,76.0,1061,0 +Clustering,78.0,1075,0 +Clustering,80.0,1089,0 +Clustering,82.0,1100,0 +Clustering,84.0,1100,0 +Clustering,86.0,1100,0 +Clustering,88.0,1100,0 +Clustering,90.0,1100,0 +Clustering,92.0,1100,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,361,0 +FGD-Full,4.0,387,0 +FGD-Full,6.0,416,0 +FGD-Full,8.0,449,0 +FGD-Full,10.0,478,0 +FGD-Full,12.0,525,0 +FGD-Full,14.0,568,0 +FGD-Full,16.0,586,0 +FGD-Full,18.0,604,0 +FGD-Full,20.0,621,0 +FGD-Full,22.0,639,0 +FGD-Full,24.0,657,0 +FGD-Full,26.0,675,0 +FGD-Full,28.0,694,0 +FGD-Full,30.0,712,0 +FGD-Full,32.0,772,0 +FGD-Full,34.0,827,0 +FGD-Full,36.0,883,0 +FGD-Full,38.0,940,0 +FGD-Full,40.0,996,0 +FGD-Full,42.0,1052,0 +FGD-Full,44.0,1074,0 +FGD-Full,46.0,1087,0 +FGD-Full,48.0,1100,0 +FGD-Full,50.0,1100,0 +FGD-Full,52.0,1100,0 +FGD-Full,54.0,1100,0 +FGD-Full,56.0,1100,0 +FGD-Full,58.0,1100,0 +FGD-Full,60.0,1100,0 +FGD-Full,62.0,1100,0 +FGD-Full,64.0,1100,0 +FGD-Full,66.0,1100,0 +FGD-Full,68.0,1100,0 +FGD-Full,70.0,1100,0 +FGD-Full,72.0,1100,0 +FGD-Full,74.0,1100,0 +FGD-Full,76.0,1100,0 +FGD-Full,78.0,1100,0 +FGD-Full,80.0,1100,0 +FGD-Full,82.0,1100,0 +FGD-Full,84.0,1100,0 +FGD-Full,86.0,1100,0 +FGD-Full,88.0,1100,0 +FGD-Full,90.0,1100,0 +FGD-Full,92.0,1100,0 +FGD-Full,94.0,1100,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,392,0 +FGD-2000,4.0,419,0 +FGD-2000,6.0,448,0 +FGD-2000,8.0,481,0 +FGD-2000,10.0,508,0 +FGD-2000,12.0,526,0 +FGD-2000,14.0,541,0 +FGD-2000,16.0,559,0 +FGD-2000,18.0,577,0 +FGD-2000,20.0,596,0 +FGD-2000,22.0,614,0 +FGD-2000,24.0,633,0 +FGD-2000,26.0,651,0 +FGD-2000,28.0,670,0 +FGD-2000,30.0,688,0 +FGD-2000,32.0,704,0 +FGD-2000,34.0,740,0 +FGD-2000,36.0,796,0 +FGD-2000,38.0,853,0 +FGD-2000,40.0,909,0 +FGD-2000,42.0,965,0 +FGD-2000,44.0,1020,0 +FGD-2000,46.0,1064,0 +FGD-2000,48.0,1078,0 +FGD-2000,50.0,1092,0 +FGD-2000,52.0,1100,0 +FGD-2000,54.0,1100,0 +FGD-2000,56.0,1100,0 +FGD-2000,58.0,1100,0 +FGD-2000,60.0,1100,0 +FGD-2000,62.0,1100,0 +FGD-2000,64.0,1100,0 +FGD-2000,66.0,1100,0 +FGD-2000,68.0,1100,0 +FGD-2000,70.0,1100,0 +FGD-2000,72.0,1100,0 +FGD-2000,74.0,1100,0 +FGD-2000,76.0,1100,0 +FGD-2000,78.0,1100,0 +FGD-2000,80.0,1100,0 +FGD-2000,82.0,1100,0 +FGD-2000,84.0,1100,0 +FGD-2000,86.0,1100,0 +FGD-2000,88.0,1100,0 +FGD-2000,90.0,1100,0 +FGD-2000,92.0,1100,0 +FGD-2000,94.0,1100,0 +FGD-2000,96.0,1100,0 +FGD-2000,98.0,1100,0 +FGD-2000,100.0,1100,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9c_failed.csv new file mode 100644 index 0000000..54f859d --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9c_failed.csv @@ -0,0 +1,5 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,1,993.0,0 +Clustering,1,808.0,0 +FGD-Full,1,1890.0,0 +FGD-2000,1,2100.0,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9d_breakdown.csv new file mode 100644 index 0000000..7ebaee3 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-01234-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,35.97218179737799,0 +Random,stranded,50.16330207277099,0 +Random,non_gpu,13.864516129851037,0 +Clustering,deficient,31.584338384926404,0 +Clustering,stranded,54.82605495073973,0 +Clustering,non_gpu,13.58960666433386,0 +FGD-Full,deficient,15.561843022882835,0 +FGD-Full,stranded,70.93830849050441,0 +FGD-Full,non_gpu,13.499848486612754,0 +FGD-2000,deficient,30.06813906553875,0 +FGD-2000,stranded,55.81839839060269,0 +FGD-2000,non_gpu,14.113462543858551,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-phased-12034-90/experiment_summary.log new file mode 100644 index 0000000..806e3ea --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-12034-90/experiment_summary.log @@ -0,0 +1,29 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-phased-12034-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: phased +Tier order: [1, 2, 0, 3, 4] + Phase 0: Tier 1 - 1600 tasks (gpu range: 0.05-0.48) + Phase 1: Tier 2 - 1478 tasks (gpu range: 0.55-0.81) + Phase 2: Tier 0 - 1088 tasks (gpu range: 0.00-0.00) + Phase 3: Tier 3 - 3911 tasks (gpu range: 1.00-1.00) + Phase 4: Tier 4 - 75 tasks (gpu range: 2.00-8.00) +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 16 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 96.2 79.6 6915 1237 26.4 +Clustering 97.1 90.2 7508 644 24.3 +FGD-Full 98.6 72.6 6522 1630 106.7 +FGD-2000 98.3 73.5 6569 1583 80.5 diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure7.png b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure7.png new file mode 100644 index 0000000..f84ac21 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure7_results.csv new file mode 100644 index 0000000..3010280 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.87256834904882,13.87256834904882,0 +Random,2.0,15.773203520619909,15.457318980947154,0 +Random,4.0,17.351393879750702,16.65721478072646,0 +Random,6.0,18.406634606185698,17.30135332538172,0 +Random,8.0,19.42962922657181,17.87474094915625,0 +Random,10.0,20.218334261487776,18.195315114651955,0 +Random,12.0,20.912601931407565,18.40111996816125,0 +Random,14.0,21.534031845392153,18.517315662096618,0 +Random,16.0,22.193240434968434,18.640862662199346,0 +Random,18.0,22.890804868634063,18.770093869579014,0 +Random,20.0,23.54257477818679,18.83259547188794,0 +Random,22.0,24.23012622552523,18.89893866980531,0 +Random,24.0,24.99933727867734,18.997097248423454,0 +Random,26.0,25.837909739307975,19.117481813902547,0 +Random,28.0,26.783745028444212,19.28110731275474,0 +Random,30.0,27.800899991981847,19.45860433791018,0 +Random,32.0,31.48595251714474,21.409552429553795,0 +Random,34.0,32.2212379182054,21.262466791874942,0 +Random,36.0,32.950302037855224,21.08772484427301,0 +Random,38.0,34.070141439702596,21.12021812155155,0 +Random,40.0,35.13021486925009,21.071885769805025,0 +Random,42.0,36.35390654453112,21.082293910807532,0 +Random,44.0,37.83315940841872,21.18038364464202,0 +Random,46.0,39.27032549520412,21.20332378168281,0 +Random,48.0,40.96784378968355,21.297163080430472,0 +Random,50.0,42.425629152319644,21.21055268016804,0 +Random,52.0,43.787211106159646,21.011947294979954,0 +Random,54.0,46.07290682655104,21.191735818105457,0 +Random,56.0,48.03593086003956,21.130004632089893,0 +Random,58.0,50.25606548529884,21.106297130772724,0 +Random,60.0,52.92734474196579,21.165294319952288,0 +Random,62.0,55.62058999852132,21.135231124016105,0 +Random,64.0,59.10185762677808,21.27120704918275,0 +Random,66.0,62.693367962996646,21.304826411736734,0 +Random,68.0,66.53596048481808,21.286304614318457,0 +Random,70.0,70.59473401530249,21.167129061776944,0 +Random,72.0,75.17811763766258,21.04506324912859,0 +Random,74.0,80.9064646796358,21.02389064413789,0 +Random,76.0,88.16581838128447,21.155409272864905,0 +Random,78.0,90.3044046919441,20.946385108215026,0 +Random,80.0,91.16469712407915,20.82190665432149,0 +Random,82.0,92.32851716061704,20.677518629075905,0 +Random,84.0,93.59897516328358,20.54619764025029,0 +Random,86.0,94.36061782967617,20.361233724683363,0 +Random,88.0,94.94177700680864,20.18293116323883,0 +Random,90.0,95.63550417012978,19.99048871599555,0 +Random,92.0,96.13408960115252,19.78718723583705,0 +Random,94.0,96.24740496610337,19.656569715131724,0 +Random,96.0,96.24740496610337,19.656569715131724,0 +Random,98.0,96.2446815889152,19.638909436714524,0 +Random,100.0,96.23922057850749,19.603588879880128,0 +Random,102.0,96.23922057850749,19.603588879880128,0 +Random,104.0,96.23922057850749,19.603588879880128,0 +Random,106.0,96.23922057850749,19.603588879880128,0 +Random,108.0,96.23922057850749,19.603588879880128,0 +Clustering,0.0,13.87256834904882,13.87256834904882,0 +Clustering,2.0,15.576959628541642,15.265005198020877,0 +Clustering,4.0,15.759228724665986,15.128747549884253,0 +Clustering,6.0,15.926424370518813,14.970074711632256,0 +Clustering,8.0,16.11022361087492,14.820976268736445,0 +Clustering,10.0,16.30991110042328,14.677963482354786,0 +Clustering,12.0,16.780396646396188,14.765168524531033,0 +Clustering,14.0,17.447418735431985,15.003198775426,0 +Clustering,16.0,18.162822874251155,15.255576928878975,0 +Clustering,18.0,18.88156971571826,15.482585169150495,0 +Clustering,20.0,19.697059834267872,15.756422708192336,0 +Clustering,22.0,20.474242201251005,15.969435902672268,0 +Clustering,24.0,21.35483994277966,16.22762902053088,0 +Clustering,26.0,22.27122296166161,16.4784885557209,0 +Clustering,28.0,23.2183107602048,16.71441917151504,0 +Clustering,30.0,24.282273638837804,16.99582226831822,0 +Clustering,32.0,24.94834886413266,16.96416783791447,0 +Clustering,34.0,25.27638051639113,16.679626112220348,0 +Clustering,36.0,25.741419526824217,16.474142527101428,0 +Clustering,38.0,26.19000458520476,16.235289496021256,0 +Clustering,40.0,26.694761634886248,16.012112932302905,0 +Clustering,42.0,27.246730483163418,15.800876295123375,0 +Clustering,44.0,27.752287983459773,15.53674384316605,0 +Clustering,46.0,28.22473571556508,15.239451226413758,0 +Clustering,48.0,28.870001188950823,15.008090897088922,0 +Clustering,50.0,29.470854978220373,14.733856268834186,0 +Clustering,52.0,30.110857015716068,14.449144502192457,0 +Clustering,54.0,30.808555041719664,14.170730790648529,0 +Clustering,56.0,31.68752474002336,13.938681577484674,0 +Clustering,58.0,32.498468295014874,13.648548120628949,0 +Clustering,60.0,33.49027900169642,13.392540573950097,0 +Clustering,62.0,34.54221191065391,13.125672206746062,0 +Clustering,64.0,35.911226834331025,12.924723046896586,0 +Clustering,66.0,37.17605481214116,12.633384043322588,0 +Clustering,68.0,38.69977400831818,12.380901576288299,0 +Clustering,70.0,40.39568870688783,12.112245599122271,0 +Clustering,72.0,42.25788609611897,11.829504563463031,0 +Clustering,74.0,44.548438444013314,11.57610213130196,0 +Clustering,76.0,47.257955387411,11.33955773308734,0 +Clustering,78.0,50.41874129654899,11.085492577233037,0 +Clustering,80.0,54.58559629743732,10.915179128110248,0 +Clustering,82.0,59.15600769726137,10.641142880961052,0 +Clustering,84.0,65.23136064627685,10.435626595659905,0 +Clustering,86.0,72.5662520095824,10.151795553926275,0 +Clustering,88.0,82.3894472150005,9.886147993525539,0 +Clustering,90.0,96.2658658382935,9.618032659372393,0 +Clustering,92.0,97.15453577285105,9.603226016857935,0 +Clustering,94.0,97.15453577285105,9.603226016857935,0 +Clustering,96.0,97.15453577285105,9.603226016857935,0 +Clustering,98.0,97.15053748235981,9.585565738440735,0 +Clustering,100.0,97.1424975359707,9.550245181606337,0 +Clustering,102.0,97.1424975359707,9.550245181606337,0 +Clustering,104.0,97.1424975359707,9.550245181606337,0 +Clustering,106.0,97.1424975359707,9.550245181606337,0 +Clustering,108.0,97.1424975359707,9.550245181606337,0 +FGD-Full,0.0,13.87256834904882,13.87256834904882,0 +FGD-Full,2.0,14.224778743169297,13.939903975696799,0 +FGD-Full,4.0,14.498126208457728,13.91809809897701,0 +FGD-Full,6.0,14.864599403181575,13.972010191818324,0 +FGD-Full,8.0,15.28653961632574,14.063208950850772,0 +FGD-Full,10.0,15.72209828513849,14.148966421360006,0 +FGD-Full,12.0,16.255044193705167,14.30290784844479,0 +FGD-Full,14.0,16.877915334570044,14.513477467307165,0 +FGD-Full,16.0,17.59385654300335,14.777682622669658,0 +FGD-Full,18.0,18.302190011672156,15.007503078613096,0 +FGD-Full,20.0,19.10243340975771,15.280758554411214,0 +FGD-Full,22.0,19.88175087224919,15.5073063543168,0 +FGD-Full,24.0,20.745888955545443,15.764884708749454,0 +FGD-Full,26.0,21.646506987685374,16.016260906818736,0 +FGD-Full,28.0,22.576494276716566,16.252387723706264,0 +FGD-Full,30.0,23.621926405139934,16.533627319598285,0 +FGD-Full,32.0,24.443927011885318,16.621175321285868,0 +FGD-Full,34.0,24.77674352259142,16.349920747838357,0 +FGD-Full,36.0,25.13169694852563,16.083928745518122,0 +FGD-Full,38.0,25.514711093264463,15.816672336151605,0 +FGD-Full,40.0,25.92293534860642,15.549154325327235,0 +FGD-Full,42.0,26.35230273161251,15.282181317540058,0 +FGD-Full,44.0,26.803724636951603,15.005703456784236,0 +FGD-Full,46.0,27.25932922068096,14.718196914567775,0 +FGD-Full,48.0,27.761771688660726,14.4319769937214,0 +FGD-Full,50.0,28.303146654625706,14.150064362678695,0 +FGD-Full,52.0,28.887380602563628,13.862041070382492,0 +FGD-Full,54.0,29.52063657367301,13.57833864936564,0 +FGD-Full,56.0,30.21789632050833,13.292222671498521,0 +FGD-Full,58.0,31.00540304417493,13.0214978628033,0 +FGD-Full,60.0,31.88731315694194,12.751525158299398,0 +FGD-Full,62.0,33.10411489757465,12.579210676025248,0 +FGD-Full,64.0,38.02004174535307,13.683701535931931,0 +FGD-Full,66.0,43.93319607357705,14.929635246471298,0 +FGD-Full,68.0,53.318818081384144,17.057852552000654,0 +FGD-Full,70.0,67.41659258028352,20.25013768956729,0 +FGD-Full,72.0,86.63678440262036,24.65306898622279,0 +FGD-Full,74.0,97.55576061648874,26.945292900328187,0 +FGD-Full,76.0,98.59738072719831,27.057770627144045,0 +FGD-Full,78.0,98.59687722413562,27.04011034872685,0 +FGD-Full,80.0,98.59687722413562,27.04011034872685,0 +FGD-Full,82.0,98.59687722413562,27.04011034872685,0 +FGD-Full,84.0,98.59687722413562,27.04011034872685,0 +FGD-Full,86.0,98.59637306810565,27.022450070309656,0 +FGD-Full,88.0,98.59637306810565,27.022450070309656,0 +FGD-Full,90.0,98.59637306810565,27.022450070309656,0 +FGD-Full,92.0,98.59637306810565,27.022450070309656,0 +FGD-Full,94.0,98.59637306810565,27.022450070309656,0 +FGD-Full,96.0,98.59637306810565,27.022450070309656,0 +FGD-Full,98.0,98.59586825783735,27.004789791892453,0 +FGD-Full,100.0,98.59485666948528,26.969469235058053,0 +FGD-Full,102.0,98.59485666948528,26.969469235058053,0 +FGD-Full,104.0,98.59485666948528,26.969469235058053,0 +FGD-Full,106.0,98.59485666948528,26.969469235058053,0 +FGD-Full,108.0,98.59485666948528,26.969469235058053,0 +FGD-2000,0.0,13.87256834904882,13.87256834904882,0 +FGD-2000,2.0,14.932542209310903,14.633493305531406,0 +FGD-2000,4.0,15.530170063716254,14.908852863655156,0 +FGD-2000,6.0,16.125356505612277,15.157061373271544,0 +FGD-2000,8.0,16.91077015803174,15.557457751800488,0 +FGD-2000,10.0,17.62266043703,15.859360898046345,0 +FGD-2000,12.0,18.0946785415997,15.921612801763757,0 +FGD-2000,14.0,18.610748721664766,16.003557125823086,0 +FGD-2000,16.0,19.27377271181818,16.188701742597008,0 +FGD-2000,18.0,19.921827918628683,16.335580257321602,0 +FGD-2000,20.0,20.574753305632246,16.458522892656323,0 +FGD-2000,22.0,21.272862858660492,16.592341565001025,0 +FGD-2000,24.0,22.065983011218453,16.768029507074793,0 +FGD-2000,26.0,22.90904949485997,16.95041671368222,0 +FGD-2000,28.0,23.741326425822052,17.0909281759245,0 +FGD-2000,30.0,24.78037676106223,17.3444581605964,0 +FGD-2000,32.0,27.700680529507466,18.83567510965015,0 +FGD-2000,34.0,28.267703934149058,18.653569974814683,0 +FGD-2000,36.0,28.88721216115176,18.487405088811027,0 +FGD-2000,38.0,29.527254025755333,18.304063887087203,0 +FGD-2000,40.0,30.17817310022817,18.101540758466335,0 +FGD-2000,42.0,30.901708214132533,17.920464589365068,0 +FGD-2000,44.0,31.639542887100554,17.712971033044983,0 +FGD-2000,46.0,32.29376003617402,17.436449572046183,0 +FGD-2000,48.0,33.03131630398071,17.17135355471909,0 +FGD-2000,50.0,33.73972071345419,16.868061544533372,0 +FGD-2000,52.0,34.55147040865437,16.58003916784227,0 +FGD-2000,54.0,35.42983033551762,16.29633674682542,0 +FGD-2000,56.0,36.400797431620816,16.011951982006007,0 +FGD-2000,58.0,37.45487507209003,15.730115651388504,0 +FGD-2000,60.0,38.624656164027414,15.445743966641981,0 +FGD-2000,62.0,39.935111896049726,15.174916697375771,0 +FGD-2000,64.0,41.418322766604945,14.90676866304039,0 +FGD-2000,66.0,43.085800136626304,14.64932518595937,0 +FGD-2000,68.0,45.191503311600925,14.682620642308292,0 +FGD-2000,70.0,50.50623657092655,15.556674822237404,0 +FGD-2000,72.0,62.96249199762346,18.39753498178291,0 +FGD-2000,74.0,86.68646381891129,23.927744020531893,0 +FGD-2000,76.0,97.82448983567468,26.098120515605967,0 +FGD-2000,78.0,98.29372126101843,26.13596334649648,0 +FGD-2000,80.0,98.29372126101843,26.13596334649648,0 +FGD-2000,82.0,98.29372126101843,26.13596334649648,0 +FGD-2000,84.0,98.29372126101843,26.13596334649648,0 +FGD-2000,86.0,98.29299850460289,26.11830306807929,0 +FGD-2000,88.0,98.29299850460289,26.11830306807929,0 +FGD-2000,90.0,98.29299850460289,26.11830306807929,0 +FGD-2000,92.0,98.29299850460289,26.11830306807929,0 +FGD-2000,94.0,98.29299850460289,26.11830306807929,0 +FGD-2000,96.0,98.29299850460289,26.11830306807929,0 +FGD-2000,98.0,98.29227478077142,26.10064278966209,0 +FGD-2000,100.0,98.29082442308102,26.065322232827693,0 +FGD-2000,102.0,98.29082442308102,26.065322232827693,0 +FGD-2000,104.0,98.29082442308102,26.065322232827693,0 +FGD-2000,106.0,98.29082442308102,26.065322232827693,0 +FGD-2000,108.0,98.29082442308102,26.065322232827693,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9.png b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9.png new file mode 100644 index 0000000..d7de7a2 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9a_unalloc.csv new file mode 100644 index 0000000..2233e66 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.99733428114456,0 +Random,4.0,95.99928914163857,0 +Random,6.0,93.99520170606016,0 +Random,8.0,91.99733428114467,0 +Random,10.0,89.99413541851813,0 +Random,12.0,87.99058112671074,0 +Random,14.0,85.99093655589141,0 +Random,16.0,83.99342456015643,0 +Random,18.0,81.99840056868678,0 +Random,20.0,79.99377998933726,0 +Random,22.0,77.99768971032526,0 +Random,24.0,75.99040341212016,0 +Random,26.0,73.99004798293943,0 +Random,28.0,71.98809312244533,0 +Random,30.0,69.99271370179491,0 +Random,32.0,67.99715656655412,0 +Random,34.0,65.98898169539721,0 +Random,36.0,63.99857828327704,0 +Random,38.0,61.99040341212012,0 +Random,40.0,59.98222854096321,0 +Random,42.0,57.991825128843075,0 +Random,44.0,55.98365025768614,0 +Random,46.0,53.99324684556602,0 +Random,48.0,51.98507197440908,0 +Random,50.0,49.994668562288936,0 +Random,52.0,47.98649369113201,0 +Random,54.0,45.9960902790119,0 +Random,56.0,43.987915407854956,0 +Random,58.0,41.997511995734804,0 +Random,60.0,39.989337124577965,0 +Random,62.0,37.99893371245789,0 +Random,64.0,35.99075884130098,0 +Random,66.0,33.98258397014406,0 +Random,68.0,31.992180558023932,0 +Random,70.0,29.984005686867015,0 +Random,72.0,27.993602274746866,0 +Random,74.0,25.985427403589927,0 +Random,76.0,23.995023991469804,0 +Random,78.0,23.195308334814392,0 +Random,80.0,22.83987915407865,0 +Random,82.0,22.39559267815898,0 +Random,84.0,21.9513062022393,0 +Random,86.0,21.578105562466764,0 +Random,88.0,21.258219299804594,0 +Random,90.0,20.902790119068833,0 +Random,92.0,20.582903856406652,0 +Random,94.0,20.422960725075566,0 +Random,96.0,20.422960725075566,0 +Random,98.0,20.40518926603878,0 +Random,100.0,20.369646347965205,0 +Random,102.0,20.369646347965205,0 +Random,104.0,20.369646347965205,0 +Random,106.0,20.369646347965205,0 +Random,108.0,20.369646347965205,0 +Clustering,2.0,97.99733428114449,0 +Clustering,4.0,95.99928914163853,0 +Clustering,6.0,93.99520170605999,0 +Clustering,8.0,91.99733428114435,0 +Clustering,10.0,89.99413541851774,0 +Clustering,12.0,87.99058112671044,0 +Clustering,14.0,85.99093655589124,0 +Clustering,16.0,83.9934245601564,0 +Clustering,18.0,81.99840056868669,0 +Clustering,20.0,79.99377998933714,0 +Clustering,22.0,77.99768971032547,0 +Clustering,24.0,75.99040341212039,0 +Clustering,26.0,73.99004798293966,0 +Clustering,28.0,71.9880931224456,0 +Clustering,30.0,69.99271370179517,0 +Clustering,32.0,67.99715656655437,0 +Clustering,34.0,65.98898169539744,0 +Clustering,36.0,63.99857828327731,0 +Clustering,38.0,61.990403412120386,0 +Clustering,40.0,59.982228540963455,0 +Clustering,42.0,57.991825128843324,0 +Clustering,44.0,55.9836502576864,0 +Clustering,46.0,53.99324684556627,0 +Clustering,48.0,51.985071974409344,0 +Clustering,50.0,49.99466856228921,0 +Clustering,52.0,47.98649369113229,0 +Clustering,54.0,45.99609027901215,0 +Clustering,56.0,43.98791540785523,0 +Clustering,58.0,41.99751199573482,0 +Clustering,60.0,39.98933712457788,0 +Clustering,62.0,37.99893371245774,0 +Clustering,64.0,35.99075884130081,0 +Clustering,66.0,33.98258397014389,0 +Clustering,68.0,31.992180558023758,0 +Clustering,70.0,29.984005686866837,0 +Clustering,72.0,27.9936022747467,0 +Clustering,74.0,25.985427403589778,0 +Clustering,76.0,23.995023991469743,0 +Clustering,78.0,21.986849120312744,0 +Clustering,80.0,19.996445708192606,0 +Clustering,82.0,17.988270837035685,0 +Clustering,84.0,15.99786742491555,0 +Clustering,86.0,13.989692553758637,0 +Clustering,88.0,11.999289141638501,0 +Clustering,90.0,9.99111427048158,0 +Clustering,92.0,9.884485516260858,0 +Clustering,94.0,9.884485516260858,0 +Clustering,96.0,9.884485516260858,0 +Clustering,98.0,9.86671405722407,0 +Clustering,100.0,9.831171139150499,0 +Clustering,102.0,9.831171139150499,0 +Clustering,104.0,9.831171139150499,0 +Clustering,106.0,9.831171139150499,0 +Clustering,108.0,9.831171139150499,0 +FGD-Full,2.0,97.99733428114448,0 +FGD-Full,4.0,95.99928914163853,0 +FGD-Full,6.0,93.99520170606006,0 +FGD-Full,8.0,91.99733428114449,0 +FGD-Full,10.0,89.99413541851786,0 +FGD-Full,12.0,87.99058112671051,0 +FGD-Full,14.0,85.99093655589124,0 +FGD-Full,16.0,83.99342456015638,0 +FGD-Full,18.0,81.99840056868668,0 +FGD-Full,20.0,79.99377998933713,0 +FGD-Full,22.0,77.9976897103252,0 +FGD-Full,24.0,75.99040341212012,0 +FGD-Full,26.0,73.99004798293939,0 +FGD-Full,28.0,71.98809312244533,0 +FGD-Full,30.0,69.9927137017949,0 +FGD-Full,32.0,67.9971565665541,0 +FGD-Full,34.0,65.98898169539717,0 +FGD-Full,36.0,63.99857828327704,0 +FGD-Full,38.0,61.99040341212012,0 +FGD-Full,40.0,59.98222854096319,0 +FGD-Full,42.0,57.991825128843054,0 +FGD-Full,44.0,55.983650257686136,0 +FGD-Full,46.0,53.993246845566,0 +FGD-Full,48.0,51.98507197440908,0 +FGD-Full,50.0,49.99466856228894,0 +FGD-Full,52.0,47.98649369113202,0 +FGD-Full,54.0,45.99609027901189,0 +FGD-Full,56.0,43.98791540785496,0 +FGD-Full,58.0,41.99751199573483,0 +FGD-Full,60.0,39.98933712457791,0 +FGD-Full,62.0,37.99893371245777,0 +FGD-Full,64.0,35.990758841300845,0 +FGD-Full,66.0,33.982583970143935,0 +FGD-Full,68.0,31.99218055802379,0 +FGD-Full,70.0,30.037320063977234,0 +FGD-Full,72.0,28.455660209703197,0 +FGD-Full,74.0,27.62040163497422,0 +FGD-Full,76.0,27.442687044606345,0 +FGD-Full,78.0,27.424915585569554,0 +FGD-Full,80.0,27.424915585569554,0 +FGD-Full,82.0,27.424915585569554,0 +FGD-Full,84.0,27.424915585569554,0 +FGD-Full,86.0,27.407144126532767,0 +FGD-Full,88.0,27.407144126532767,0 +FGD-Full,90.0,27.407144126532767,0 +FGD-Full,92.0,27.407144126532767,0 +FGD-Full,94.0,27.407144126532767,0 +FGD-Full,96.0,27.407144126532767,0 +FGD-Full,98.0,27.389372667495987,0 +FGD-Full,100.0,27.353829749422413,0 +FGD-Full,102.0,27.353829749422413,0 +FGD-Full,104.0,27.353829749422413,0 +FGD-Full,106.0,27.353829749422413,0 +FGD-Full,108.0,27.353829749422413,0 +FGD-2000,2.0,97.99733428114449,0 +FGD-2000,4.0,95.99928914163853,0 +FGD-2000,6.0,93.99520170606009,0 +FGD-2000,8.0,91.99733428114449,0 +FGD-2000,10.0,89.99413541851786,0 +FGD-2000,12.0,87.9905811267105,0 +FGD-2000,14.0,85.99093655589122,0 +FGD-2000,16.0,83.99342456015638,0 +FGD-2000,18.0,81.99840056868668,0 +FGD-2000,20.0,79.99377998933711,0 +FGD-2000,22.0,77.9976897103252,0 +FGD-2000,24.0,75.99040341212012,0 +FGD-2000,26.0,73.99004798293937,0 +FGD-2000,28.0,71.98809312244533,0 +FGD-2000,30.0,69.99271370179488,0 +FGD-2000,32.0,67.99715656655407,0 +FGD-2000,34.0,65.98898169539716,0 +FGD-2000,36.0,63.99857828327702,0 +FGD-2000,38.0,61.9904034121201,0 +FGD-2000,40.0,59.98222854096318,0 +FGD-2000,42.0,57.991825128843054,0 +FGD-2000,44.0,55.98365025768612,0 +FGD-2000,46.0,53.99324684556599,0 +FGD-2000,48.0,51.98507197440907,0 +FGD-2000,50.0,49.994668562288936,0 +FGD-2000,52.0,47.986493691132004,0 +FGD-2000,54.0,45.99609027901188,0 +FGD-2000,56.0,43.987915407854956,0 +FGD-2000,58.0,41.99751199573482,0 +FGD-2000,60.0,39.9893371245779,0 +FGD-2000,62.0,37.99893371245776,0 +FGD-2000,64.0,35.99075884130084,0 +FGD-2000,66.0,34.00035542918071,0 +FGD-2000,68.0,32.48978141105382,0 +FGD-2000,70.0,30.80149280255908,0 +FGD-2000,72.0,29.219832948285042,0 +FGD-2000,74.0,27.60263017593743,0 +FGD-2000,76.0,26.678514306024514,0 +FGD-2000,78.0,26.58965701084058,0 +FGD-2000,80.0,26.58965701084058,0 +FGD-2000,82.0,26.58965701084058,0 +FGD-2000,84.0,26.58965701084058,0 +FGD-2000,86.0,26.57188555180379,0 +FGD-2000,88.0,26.57188555180379,0 +FGD-2000,90.0,26.57188555180379,0 +FGD-2000,92.0,26.57188555180379,0 +FGD-2000,94.0,26.57188555180379,0 +FGD-2000,96.0,26.57188555180379,0 +FGD-2000,98.0,26.554114092767,0 +FGD-2000,100.0,26.518571174693427,0 +FGD-2000,102.0,26.518571174693427,0 +FGD-2000,104.0,26.518571174693427,0 +FGD-2000,106.0,26.518571174693427,0 +FGD-2000,108.0,26.518571174693427,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9b_occupied.csv new file mode 100644 index 0000000..1b92648 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,258,0 +Random,4.0,471,0 +Random,6.0,619,0 +Random,8.0,733,0 +Random,10.0,813,0 +Random,12.0,860,0 +Random,14.0,891,0 +Random,16.0,921,0 +Random,18.0,952,0 +Random,20.0,973,0 +Random,22.0,993,0 +Random,24.0,1007,0 +Random,26.0,1023,0 +Random,28.0,1035,0 +Random,30.0,1051,0 +Random,32.0,1080,0 +Random,34.0,1085,0 +Random,36.0,1088,0 +Random,38.0,1092,0 +Random,40.0,1094,0 +Random,42.0,1095,0 +Random,44.0,1097,0 +Random,46.0,1098,0 +Random,48.0,1098,0 +Random,50.0,1100,0 +Random,52.0,1100,0 +Random,54.0,1100,0 +Random,56.0,1100,0 +Random,58.0,1100,0 +Random,60.0,1100,0 +Random,62.0,1100,0 +Random,64.0,1100,0 +Random,66.0,1100,0 +Random,68.0,1100,0 +Random,70.0,1100,0 +Random,72.0,1100,0 +Random,74.0,1100,0 +Random,76.0,1100,0 +Random,78.0,1100,0 +Random,80.0,1100,0 +Random,82.0,1100,0 +Random,84.0,1100,0 +Random,86.0,1100,0 +Random,88.0,1100,0 +Random,90.0,1100,0 +Random,92.0,1100,0 +Random,94.0,1100,0 +Random,96.0,1100,0 +Random,98.0,1100,0 +Random,100.0,1100,0 +Random,102.0,1100,0 +Random,104.0,1100,0 +Random,106.0,1100,0 +Random,108.0,1100,0 +Clustering,2.0,134,0 +Clustering,4.0,195,0 +Clustering,6.0,256,0 +Clustering,8.0,316,0 +Clustering,10.0,377,0 +Clustering,12.0,446,0 +Clustering,14.0,506,0 +Clustering,16.0,543,0 +Clustering,18.0,561,0 +Clustering,20.0,580,0 +Clustering,22.0,598,0 +Clustering,24.0,617,0 +Clustering,26.0,635,0 +Clustering,28.0,653,0 +Clustering,30.0,672,0 +Clustering,32.0,688,0 +Clustering,34.0,702,0 +Clustering,36.0,717,0 +Clustering,38.0,731,0 +Clustering,40.0,746,0 +Clustering,42.0,760,0 +Clustering,44.0,774,0 +Clustering,46.0,788,0 +Clustering,48.0,802,0 +Clustering,50.0,816,0 +Clustering,52.0,830,0 +Clustering,54.0,844,0 +Clustering,56.0,859,0 +Clustering,58.0,873,0 +Clustering,60.0,887,0 +Clustering,62.0,901,0 +Clustering,64.0,915,0 +Clustering,66.0,929,0 +Clustering,68.0,943,0 +Clustering,70.0,958,0 +Clustering,72.0,971,0 +Clustering,74.0,986,0 +Clustering,76.0,1000,0 +Clustering,78.0,1014,0 +Clustering,80.0,1029,0 +Clustering,82.0,1043,0 +Clustering,84.0,1058,0 +Clustering,86.0,1072,0 +Clustering,88.0,1086,0 +Clustering,90.0,1100,0 +Clustering,92.0,1100,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,92,0 +FGD-Full,4.0,126,0 +FGD-Full,6.0,158,0 +FGD-Full,8.0,194,0 +FGD-Full,10.0,226,0 +FGD-Full,12.0,274,0 +FGD-Full,14.0,309,0 +FGD-Full,16.0,327,0 +FGD-Full,18.0,346,0 +FGD-Full,20.0,364,0 +FGD-Full,22.0,383,0 +FGD-Full,24.0,401,0 +FGD-Full,26.0,420,0 +FGD-Full,28.0,438,0 +FGD-Full,30.0,457,0 +FGD-Full,32.0,627,0 +FGD-Full,34.0,642,0 +FGD-Full,36.0,657,0 +FGD-Full,38.0,673,0 +FGD-Full,40.0,689,0 +FGD-Full,42.0,705,0 +FGD-Full,44.0,734,0 +FGD-Full,46.0,774,0 +FGD-Full,48.0,828,0 +FGD-Full,50.0,883,0 +FGD-Full,52.0,938,0 +FGD-Full,54.0,993,0 +FGD-Full,56.0,1049,0 +FGD-Full,58.0,1073,0 +FGD-Full,60.0,1087,0 +FGD-Full,62.0,1100,0 +FGD-Full,64.0,1100,0 +FGD-Full,66.0,1100,0 +FGD-Full,68.0,1100,0 +FGD-Full,70.0,1100,0 +FGD-Full,72.0,1100,0 +FGD-Full,74.0,1100,0 +FGD-Full,76.0,1100,0 +FGD-Full,78.0,1100,0 +FGD-Full,80.0,1100,0 +FGD-Full,82.0,1100,0 +FGD-Full,84.0,1100,0 +FGD-Full,86.0,1100,0 +FGD-Full,88.0,1100,0 +FGD-Full,90.0,1100,0 +FGD-Full,92.0,1100,0 +FGD-Full,94.0,1100,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,137,0 +FGD-2000,4.0,184,0 +FGD-2000,6.0,210,0 +FGD-2000,8.0,237,0 +FGD-2000,10.0,262,0 +FGD-2000,12.0,300,0 +FGD-2000,14.0,316,0 +FGD-2000,16.0,333,0 +FGD-2000,18.0,350,0 +FGD-2000,20.0,366,0 +FGD-2000,22.0,383,0 +FGD-2000,24.0,400,0 +FGD-2000,26.0,417,0 +FGD-2000,28.0,434,0 +FGD-2000,30.0,452,0 +FGD-2000,32.0,605,0 +FGD-2000,34.0,618,0 +FGD-2000,36.0,632,0 +FGD-2000,38.0,646,0 +FGD-2000,40.0,660,0 +FGD-2000,42.0,675,0 +FGD-2000,44.0,689,0 +FGD-2000,46.0,700,0 +FGD-2000,48.0,716,0 +FGD-2000,50.0,761,0 +FGD-2000,52.0,816,0 +FGD-2000,54.0,871,0 +FGD-2000,56.0,927,0 +FGD-2000,58.0,983,0 +FGD-2000,60.0,1039,0 +FGD-2000,62.0,1069,0 +FGD-2000,64.0,1083,0 +FGD-2000,66.0,1099,0 +FGD-2000,68.0,1100,0 +FGD-2000,70.0,1100,0 +FGD-2000,72.0,1100,0 +FGD-2000,74.0,1100,0 +FGD-2000,76.0,1100,0 +FGD-2000,78.0,1100,0 +FGD-2000,80.0,1100,0 +FGD-2000,82.0,1100,0 +FGD-2000,84.0,1100,0 +FGD-2000,86.0,1100,0 +FGD-2000,88.0,1100,0 +FGD-2000,90.0,1100,0 +FGD-2000,92.0,1100,0 +FGD-2000,94.0,1100,0 +FGD-2000,96.0,1100,0 +FGD-2000,98.0,1100,0 +FGD-2000,100.0,1100,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9c_failed.csv new file mode 100644 index 0000000..4dce483 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9c_failed.csv @@ -0,0 +1,5 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,1,925.0,0 +Clustering,1,332.0,0 +FGD-Full,1,1318.0,0 +FGD-2000,1,1271.0,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9d_breakdown.csv new file mode 100644 index 0000000..27a1f5a --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-12034-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,37.77336546995123,0 +Random,stranded,48.35867303088992,0 +Random,non_gpu,13.867961499158843,0 +Clustering,deficient,64.55323042114183,0 +Clustering,stranded,21.707758954825163,0 +Clustering,non_gpu,13.73901062403301,0 +FGD-Full,deficient,21.954979006555494,0 +FGD-Full,stranded,64.50839392408395,0 +FGD-Full,non_gpu,13.536627069360554,0 +FGD-2000,deficient,25.452209639353917,0 +FGD-2000,stranded,60.969291924748894,0 +FGD-2000,non_gpu,13.578498435897185,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-phased-24031-90/experiment_summary.log new file mode 100644 index 0000000..8d555bb --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-24031-90/experiment_summary.log @@ -0,0 +1,29 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-phased-24031-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: phased +Tier order: [2, 4, 0, 3, 1] + Phase 0: Tier 2 - 1478 tasks (gpu range: 0.55-0.81) + Phase 1: Tier 4 - 75 tasks (gpu range: 2.00-8.00) + Phase 2: Tier 0 - 1088 tasks (gpu range: 0.00-0.00) + Phase 3: Tier 3 - 3911 tasks (gpu range: 1.00-1.00) + Phase 4: Tier 1 - 1600 tasks (gpu range: 0.05-0.48) +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 8 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 99.4 87.4 6274 1878 25.6 +Clustering 99.3 95.3 6781 1371 23.1 +FGD-Full 99.4 81.2 5972 2180 104.8 +FGD-2000 99.6 83.3 5827 2325 64.9 diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure7.png b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure7.png new file mode 100644 index 0000000..f32a609 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure7_results.csv new file mode 100644 index 0000000..3b472e4 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.87256834904882,13.87256834904882,0 +Random,2.0,14.468675713754845,14.177785135560917,0 +Random,4.0,15.074239390126309,14.470894766802257,0 +Random,6.0,15.713888264305151,14.77002171117688,0 +Random,8.0,16.34299849882293,15.034193555953745,0 +Random,10.0,16.94935139558925,15.25300054692133,0 +Random,12.0,17.608834107105746,15.493552178067452,0 +Random,14.0,18.30393597234235,15.740246429445163,0 +Random,16.0,19.028743240855064,15.98211531113205,0 +Random,18.0,19.820098155719727,16.250120532871545,0 +Random,20.0,20.58988118054168,16.449657480851048,0 +Random,22.0,20.769193688145865,16.186904976583904,0 +Random,24.0,20.95725371058721,15.923788410287907,0 +Random,26.0,21.165451878230385,15.653181322248727,0 +Random,28.0,23.2833851512315,16.76023053541257,0 +Random,30.0,23.82955033212758,16.679075986154515,0 +Random,32.0,24.432504622486352,16.61045585274824,0 +Random,34.0,25.038817723491636,16.524284768534034,0 +Random,36.0,25.85969069406114,16.546709354501754,0 +Random,38.0,26.470169485225686,16.410470171068038,0 +Random,40.0,27.308620603529533,16.381872226697418,0 +Random,42.0,28.17635494499413,16.341584839183867,0 +Random,44.0,28.85925337128606,16.15810466168554,0 +Random,46.0,29.916192614471314,16.15442501917963,0 +Random,48.0,30.779340234080898,16.002412554044568,0 +Random,50.0,31.527005859206465,15.75801217685015,0 +Random,52.0,32.64664188652497,15.667835320312573,0 +Random,54.0,33.79167420960348,15.53876539023168,0 +Random,56.0,35.60990717672672,15.666080933735744,0 +Random,58.0,37.375544926354145,15.692282281750622,0 +Random,60.0,39.00806669092608,15.601285631644496,0 +Random,62.0,40.70234261832491,15.461537478855986,0 +Random,64.0,43.05916333395427,15.499768351908989,0 +Random,66.0,45.303023904954316,15.397714462183066,0 +Random,68.0,48.20121845402034,15.423361978111533,0 +Random,70.0,51.45436570931579,15.4310060817106,0 +Random,72.0,54.9356229027118,15.381583898290655,0 +Random,74.0,59.005465870581354,15.336178060253012,0 +Random,76.0,64.57878413833176,15.487890664717007,0 +Random,78.0,70.12411593502486,15.422071432719594,0 +Random,80.0,76.64202433491752,15.316418909739205,0 +Random,82.0,85.17613805382197,15.326558255243752,0 +Random,84.0,89.56588849517692,15.09774952113844,0 +Random,86.0,91.37720036594781,14.948381105538136,0 +Random,88.0,92.79680637598838,14.751839210849463,0 +Random,90.0,93.97151658285681,14.604579826202363,0 +Random,92.0,95.3230626207425,14.441943725863895,0 +Random,94.0,96.61953602003052,14.226269412354082,0 +Random,96.0,97.73940466840281,14.078504046887256,0 +Random,98.0,98.43282799292459,13.838847441528932,0 +Random,100.0,98.9608843899816,13.266069719753263,0 +Random,102.0,99.3551328193761,12.747897421882676,0 +Random,104.0,99.36244324597261,12.661074361435126,0 +Random,106.0,99.36536141693063,12.610059461139292,0 +Random,108.0,99.37104018403946,12.522128518517734,0 +Clustering,0.0,13.87256834904882,13.87256834904882,0 +Clustering,2.0,14.13095565426556,13.846854887752844,0 +Clustering,4.0,14.640035298981113,14.05406964231922,0 +Clustering,6.0,15.21111870744373,14.297451387036983,0 +Clustering,8.0,15.794732584179716,14.529834708862735,0 +Clustering,10.0,16.405524532115198,14.76360179339991,0 +Clustering,12.0,17.040485405108825,14.993477033048618,0 +Clustering,14.0,17.73888338349212,15.254336349365403,0 +Clustering,16.0,18.430817850540738,15.47992173930766,0 +Clustering,18.0,19.19999646765432,15.74171098340676,0 +Clustering,20.0,19.99247176593749,15.972375452853719,0 +Clustering,22.0,20.157912988467512,15.710490593421774,0 +Clustering,24.0,20.358153876675882,15.468579005296876,0 +Clustering,26.0,20.5486463592289,15.197014891924388,0 +Clustering,28.0,20.784311037029084,14.961305765364724,0 +Clustering,30.0,20.990634049511627,14.692026304724152,0 +Clustering,32.0,21.21335093218587,14.421911899430595,0 +Clustering,34.0,21.58560481598871,14.24534835547728,0 +Clustering,36.0,21.890834862453012,14.007177668199677,0 +Clustering,38.0,22.236499611899486,13.785760374285386,0 +Clustering,40.0,22.557281422663998,13.531642898139514,0 +Clustering,42.0,22.87128201621981,13.264774530935483,0 +Clustering,44.0,23.183424830397204,12.98024588531425,0 +Clustering,46.0,23.543708151095124,12.71335135796443,0 +Clustering,48.0,23.905880870920456,12.428848872488981,0 +Clustering,50.0,24.32768241695153,12.159604292042795,0 +Clustering,52.0,24.81211724650642,11.907876109211983,0 +Clustering,54.0,25.277760412734857,11.62372678570464,0 +Clustering,56.0,25.941517127666913,11.412607869181146,0 +Clustering,58.0,26.462913141664917,11.110567185968835,0 +Clustering,60.0,27.131561074437933,10.851274360981785,0 +Clustering,62.0,27.936903521239604,10.612349389500718,0 +Clustering,64.0,28.725683354488872,10.340225013006004,0 +Clustering,66.0,29.690762070859595,10.091376626223724,0 +Clustering,68.0,30.656256944482667,9.809348454537133,0 +Clustering,70.0,31.823030318259388,9.543628953735492,0 +Clustering,72.0,33.22991277400441,9.304139359107872,0 +Clustering,74.0,34.81946671650132,9.049967382658272,0 +Clustering,76.0,36.73917456479714,8.811133971687443,0 +Clustering,78.0,39.16426479300082,8.61321502872476,0 +Clustering,80.0,42.095291919471464,8.412475150041567,0 +Clustering,82.0,45.191392795566024,8.131720105449858,0 +Clustering,84.0,49.33531677586071,7.8866365996485,0 +Clustering,86.0,54.4073296928157,7.6145122231537705,0 +Clustering,88.0,61.299634357805076,7.348112558561715,0 +Clustering,90.0,70.9196035912839,7.089691738434169,0 +Clustering,92.0,85.39110701835142,6.8215764042810365,0 +Clustering,94.0,96.69561464320459,6.676413755318627,0 +Clustering,96.0,96.68175366829834,6.641093198484225,0 +Clustering,98.0,96.8471518494838,6.438864044501587,0 +Clustering,100.0,97.56756253392084,5.865497610445118,0 +Clustering,102.0,98.55201029202034,5.26895091100966,0 +Clustering,104.0,99.26769546751409,4.830545650064799,0 +Clustering,106.0,99.27459215078167,4.779541453628612,0 +Clustering,108.0,99.28259022386024,4.69135381457653,0 +FGD-Full,0.0,13.87256834904882,13.87256834904882,0 +FGD-Full,2.0,14.142865912274505,13.8585256917919,0 +FGD-Full,4.0,14.624938891313144,14.039577466557226,0 +FGD-Full,6.0,15.202625922418534,14.289468727551244,0 +FGD-Full,8.0,15.798406356667458,14.533214272696416,0 +FGD-Full,10.0,16.428943063779975,14.784676515845204,0 +FGD-Full,12.0,17.083928995583058,15.031701911068332,0 +FGD-Full,14.0,17.778950215087654,15.288791332376261,0 +FGD-Full,16.0,18.481934075197938,15.522853917560237,0 +FGD-Full,18.0,19.25407540082629,15.786049269495303,0 +FGD-Full,20.0,20.048010511120744,16.016746439124496,0 +FGD-Full,22.0,20.215012615295713,15.754992380421479,0 +FGD-Full,24.0,20.389586532120816,15.492462237393498,0 +FGD-Full,26.0,20.581771328183944,15.221512887446961,0 +FGD-Full,28.0,20.983458585629787,15.104659440246165,0 +FGD-Full,30.0,21.203972556974044,14.841348852868922,0 +FGD-Full,32.0,21.434462963629606,14.572235073151651,0 +FGD-Full,34.0,21.678035549055817,14.306347711414565,0 +FGD-Full,36.0,21.939054644729335,14.038031816143748,0 +FGD-Full,38.0,22.21612998162369,13.773131999910055,0 +FGD-Full,40.0,22.517150943062138,13.507569459983134,0 +FGD-Full,42.0,22.830398269100836,13.241062974795797,0 +FGD-Full,44.0,23.171043896836377,12.973313882683657,0 +FGD-Full,46.0,23.52738276738658,12.704535824837299,0 +FGD-Full,48.0,23.917945189838576,12.435121203443495,0 +FGD-Full,50.0,24.340192196055696,12.165857002887961,0 +FGD-Full,52.0,24.796010691256956,11.900146222134927,0 +FGD-Full,54.0,25.293093125025468,11.63077738099625,0 +FGD-Full,56.0,25.800931484590873,11.350759180510824,0 +FGD-Full,58.0,26.36200169993643,11.068199085859929,0 +FGD-Full,60.0,26.973720549539017,10.78814600518012,0 +FGD-Full,62.0,27.655775126538828,10.505557570371295,0 +FGD-Full,64.0,28.407062499290408,10.225532829849424,0 +FGD-Full,66.0,29.25412941091446,9.942972735198529,0 +FGD-Full,68.0,30.23388005486691,9.67419685736431,0 +FGD-Full,70.0,31.36425045415681,9.406042282992482,0 +FGD-Full,72.0,33.77713463052937,9.457357588962436,0 +FGD-Full,74.0,40.86415981038788,10.621050471990133,0 +FGD-Full,76.0,54.033873373443086,12.968513713933241,0 +FGD-Full,78.0,79.1040338645452,17.706257816433617,0 +FGD-Full,80.0,93.5188651965627,20.118439079037334,0 +FGD-Full,82.0,95.66567205385383,20.291255182106916,0 +FGD-Full,84.0,98.32611515929227,20.541019173991693,0 +FGD-Full,86.0,98.32611515929227,20.541019173991693,0 +FGD-Full,88.0,98.32611515929227,20.541019173991693,0 +FGD-Full,90.0,98.32611515929227,20.541019173991693,0 +FGD-Full,92.0,98.32611515929227,20.541019173991693,0 +FGD-Full,94.0,98.32611515929227,20.541019173991693,0 +FGD-Full,96.0,98.32432861710416,20.505698617157293,0 +FGD-Full,98.0,98.42373451670477,20.30936242841498,0 +FGD-Full,100.0,98.74098896175299,19.7460920666219,0 +FGD-Full,102.0,99.15443658209155,19.169035417000615,0 +FGD-Full,104.0,99.43243776893792,18.857352104051852,0 +FGD-Full,106.0,99.43533147390121,18.80647796714046,0 +FGD-Full,108.0,99.43997638145834,18.71864335925575,0 +FGD-2000,0.0,13.87256834904882,13.87256834904882,0 +FGD-2000,2.0,14.172259180071414,13.88732801230147,0 +FGD-2000,4.0,14.650128903280665,14.063759251317473,0 +FGD-2000,6.0,15.223931233606338,14.30949431914986,0 +FGD-2000,8.0,15.820165801261249,14.553231144246434,0 +FGD-2000,10.0,16.45118851892763,14.804695567407375,0 +FGD-2000,12.0,17.10667870245573,15.051718782618352,0 +FGD-2000,14.0,17.802229865737566,15.308810383938429,0 +FGD-2000,16.0,18.505808238789275,15.542905669304641,0 +FGD-2000,18.0,19.27849242383507,15.80606832105747,0 +FGD-2000,20.0,20.073068169220434,16.036765490686662,0 +FGD-2000,22.0,20.240785494662244,15.775079012360257,0 +FGD-2000,24.0,20.41150278690906,15.509114696194318,0 +FGD-2000,26.0,20.603279838577432,15.237419782092903,0 +FGD-2000,28.0,22.686655198183473,16.330682533027566,0 +FGD-2000,30.0,23.093966252219023,16.164216805347372,0 +FGD-2000,32.0,23.489776882891753,15.969541720462072,0 +FGD-2000,34.0,23.875608435048466,15.756628653940144,0 +FGD-2000,36.0,24.343702604368108,15.576681731131947,0 +FGD-2000,38.0,24.768025996149188,15.35520775690179,0 +FGD-2000,40.0,25.16742693528602,15.097414780273086,0 +FGD-2000,42.0,25.571004518538132,14.830546413069051,0 +FGD-2000,44.0,26.014542202712793,14.565369735292466,0 +FGD-2000,46.0,26.47852663556559,14.298122045974546,0 +FGD-2000,48.0,26.97614764060232,14.025103864498828,0 +FGD-2000,50.0,27.513545619519046,13.75198104243997,0 +FGD-2000,52.0,28.11025889979802,13.490726206519021,0 +FGD-2000,54.0,28.765001832529872,13.227300078497903,0 +FGD-2000,56.0,29.479953425235355,12.969293460678625,0 +FGD-2000,58.0,30.255482870231436,12.702893796086578,0 +FGD-2000,60.0,31.09932786529318,12.438183640909829,0 +FGD-2000,62.0,32.05392724937893,12.176276981356398,0 +FGD-2000,64.0,33.05120595209068,11.89725940644726,0 +FGD-2000,66.0,34.167319771414135,11.612881181664289,0 +FGD-2000,68.0,35.411636657381,11.33096855062158,0 +FGD-2000,70.0,36.83462344949622,11.046590325838611,0 +FGD-2000,72.0,38.452894967063955,10.766537245158805,0 +FGD-2000,74.0,40.329779290303605,10.482159020375835,0 +FGD-2000,76.0,42.562911166437665,10.207837191635145,0 +FGD-2000,78.0,45.207108616390855,9.942189631234408,0 +FGD-2000,80.0,49.053032604379105,9.898827009583181,0 +FGD-2000,82.0,72.25509080818493,13.39961477877326,0 +FGD-2000,84.0,96.27936953751389,16.811161570641218,0 +FGD-2000,86.0,99.28822844599058,17.071858323452073,0 +FGD-2000,88.0,99.28822844599058,17.071858323452073,0 +FGD-2000,90.0,99.28822844599058,17.071858323452073,0 +FGD-2000,92.0,99.28822844599058,17.071858323452073,0 +FGD-2000,94.0,99.28822844599058,17.071858323452073,0 +FGD-2000,96.0,99.28804997592763,17.036537766617673,0 +FGD-2000,98.0,99.41024940661552,16.886139077275857,0 +FGD-2000,100.0,99.5495757358404,16.755713288639026,0 +FGD-2000,102.0,99.55313421362429,16.728004963626073,0 +FGD-2000,104.0,99.55304456506406,16.7141901176387,0 +FGD-2000,106.0,99.55289495140495,16.691165396126532,0 +FGD-2000,108.0,99.55271186759103,16.662827549005378,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9.png b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9.png new file mode 100644 index 0000000..dcc7479 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9a_unalloc.csv new file mode 100644 index 0000000..0d9bc8e --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.98951483916811,0 +Random,4.0,95.99751199573461,0 +Random,6.0,93.99342456015607,0 +Random,8.0,91.99164741425237,0 +Random,10.0,89.99164741425231,0 +Random,12.0,87.98738226408351,0 +Random,14.0,85.99377998933683,0 +Random,16.0,83.9893371245777,0 +Random,18.0,81.98809312244526,0 +Random,20.0,79.89194952905643,0 +Random,22.0,77.93708903500993,0 +Random,24.0,75.9822285409634,0 +Random,26.0,73.95628221076974,0 +Random,28.0,71.9836502576864,0 +Random,30.0,69.99324684556628,0 +Random,32.0,67.98507197440937,0 +Random,34.0,65.9946685622892,0 +Random,36.0,63.986493691132296,0 +Random,38.0,61.99609027901214,0 +Random,40.0,59.98791540785523,0 +Random,42.0,57.99751199573508,0 +Random,44.0,55.989337124578164,0 +Random,46.0,53.99893371245803,0 +Random,48.0,51.99075884130111,0 +Random,50.0,49.98258397014419,0 +Random,52.0,47.99218055802405,0 +Random,54.0,45.984005686867135,0 +Random,56.0,43.993602274747005,0 +Random,58.0,41.985427403590094,0 +Random,60.0,39.99502399146998,0 +Random,62.0,37.98684912031311,0 +Random,64.0,35.996445708192994,0 +Random,66.0,33.98827083703607,0 +Random,68.0,31.997867424915917,0 +Random,70.0,29.989692553758996,0 +Random,72.0,27.999289141638855,0 +Random,74.0,25.991114270481923,0 +Random,76.0,23.982939399324994,0 +Random,78.0,21.992535987204853,0 +Random,80.0,19.984361116047868,0 +Random,82.0,17.993957703927656,0 +Random,84.0,16.85658432557329,0 +Random,86.0,16.358983472543255,0 +Random,88.0,15.896925537586789,0 +Random,90.0,15.541496356851042,0 +Random,92.0,15.150524258041726,0 +Random,94.0,14.724009241158834,0 +Random,96.0,14.40412297849667,0 +Random,98.0,14.05917895859263,0 +Random,100.0,13.405366980629232,0 +Random,102.0,12.83063799537954,0 +Random,104.0,12.742313843966702,0 +Random,106.0,12.69059889816965,0 +Random,108.0,12.601386173804974,0 +Clustering,2.0,97.98951483916831,0 +Clustering,4.0,95.9975119957349,0 +Clustering,6.0,93.99342456015656,0 +Clustering,8.0,91.991647414253,0 +Clustering,10.0,89.99164741425314,0 +Clustering,12.0,87.98738226408443,0 +Clustering,14.0,85.99377998933774,0 +Clustering,16.0,83.98933712457854,0 +Clustering,18.0,81.98809312244597,0 +Clustering,20.0,79.89194952905683,0 +Clustering,22.0,77.93708903501,0 +Clustering,24.0,75.98222854096345,0 +Clustering,26.0,73.95628221076974,0 +Clustering,28.0,71.98365025768638,0 +Clustering,30.0,69.99324684556623,0 +Clustering,32.0,67.98507197440932,0 +Clustering,34.0,65.99466856228918,0 +Clustering,36.0,63.98649369113226,0 +Clustering,38.0,61.99609027901213,0 +Clustering,40.0,59.987915407855205,0 +Clustering,42.0,57.99751199573506,0 +Clustering,44.0,55.98933712457814,0 +Clustering,46.0,53.99893371245801,0 +Clustering,48.0,51.99075884130109,0 +Clustering,50.0,49.98258397014417,0 +Clustering,52.0,47.99218055802403,0 +Clustering,54.0,45.98400568686711,0 +Clustering,56.0,43.993602274746976,0 +Clustering,58.0,41.98542740359012,0 +Clustering,60.0,39.99502399147,0 +Clustering,62.0,37.986849120313074,0 +Clustering,64.0,35.996445708192944,0 +Clustering,66.0,33.98827083703602,0 +Clustering,68.0,31.99786742491588,0 +Clustering,70.0,29.989692553758964,0 +Clustering,72.0,27.999289141638826,0 +Clustering,74.0,25.99111427048191,0 +Clustering,76.0,23.982939399324785,0 +Clustering,78.0,21.992535987204484,0 +Clustering,80.0,19.984361116047562,0 +Clustering,82.0,17.993957703927432,0 +Clustering,84.0,15.985782832770528,0 +Clustering,86.0,13.99537942065045,0 +Clustering,88.0,11.987204549493539,0 +Clustering,90.0,9.99680113737339,0 +Clustering,92.0,7.988626266216469,0 +Clustering,94.0,6.904567264972466,0 +Clustering,96.0,6.869024346898891,0 +Clustering,98.0,6.648480540252363,0 +Clustering,100.0,6.011729162964269,0 +Clustering,102.0,5.34636573662697,0 +Clustering,104.0,4.866180913452981,0 +Clustering,106.0,4.814465967655933,0 +Clustering,108.0,4.725253243291263,0 +FGD-Full,2.0,97.9895148391683,0 +FGD-Full,4.0,95.99751199573484,0 +FGD-Full,6.0,93.99342456015638,0 +FGD-Full,8.0,91.99164741425271,0 +FGD-Full,10.0,89.99164741425271,0 +FGD-Full,12.0,87.98738226408388,0 +FGD-Full,14.0,85.99377998933714,0 +FGD-Full,16.0,83.98933712457793,0 +FGD-Full,18.0,81.98809312244536,0 +FGD-Full,20.0,79.89194952905633,0 +FGD-Full,22.0,77.93708903500978,0 +FGD-Full,24.0,75.98222854096322,0 +FGD-Full,26.0,73.9562822107695,0 +FGD-Full,28.0,71.98365025768616,0 +FGD-Full,30.0,69.99324684556602,0 +FGD-Full,32.0,67.9850719744091,0 +FGD-Full,34.0,65.99466856228896,0 +FGD-Full,36.0,63.98649369113204,0 +FGD-Full,38.0,61.99609027901191,0 +FGD-Full,40.0,59.987915407854985,0 +FGD-Full,42.0,57.997511995734854,0 +FGD-Full,44.0,55.98933712457793,0 +FGD-Full,46.0,53.9989337124578,0 +FGD-Full,48.0,51.99075884130087,0 +FGD-Full,50.0,49.98258397014395,0 +FGD-Full,52.0,47.99218055802381,0 +FGD-Full,54.0,45.984005686866894,0 +FGD-Full,56.0,43.993602274746756,0 +FGD-Full,58.0,41.98542740358984,0 +FGD-Full,60.0,39.995023991469694,0 +FGD-Full,62.0,37.986849120312776,0 +FGD-Full,64.0,35.996445708192645,0 +FGD-Full,66.0,33.98827083703572,0 +FGD-Full,68.0,31.997867424915583,0 +FGD-Full,70.0,29.989692553758662,0 +FGD-Full,72.0,27.999289141638528,0 +FGD-Full,74.0,25.991114270481606,0 +FGD-Full,76.0,24.000710858361472,0 +FGD-Full,78.0,22.38350808601386,0 +FGD-Full,80.0,21.512706593211302,0 +FGD-Full,82.0,21.210591789585926,0 +FGD-Full,84.0,20.89070552692376,0 +FGD-Full,86.0,20.89070552692376,0 +FGD-Full,88.0,20.89070552692376,0 +FGD-Full,90.0,20.89070552692376,0 +FGD-Full,92.0,20.89070552692376,0 +FGD-Full,94.0,20.89070552692376,0 +FGD-Full,96.0,20.855162608850186,0 +FGD-Full,98.0,20.634618802203665,0 +FGD-Full,100.0,19.99786742491559,0 +FGD-Full,102.0,19.332503998578282,0 +FGD-Full,104.0,18.96499022569753,0 +FGD-Full,106.0,18.91327527990048,0 +FGD-Full,108.0,18.824062555535807,0 +FGD-2000,2.0,97.9895148391683,0 +FGD-2000,4.0,95.99751199573484,0 +FGD-2000,6.0,93.99342456015638,0 +FGD-2000,8.0,91.99164741425271,0 +FGD-2000,10.0,89.99164741425271,0 +FGD-2000,12.0,87.98738226408388,0 +FGD-2000,14.0,85.99377998933714,0 +FGD-2000,16.0,83.98933712457793,0 +FGD-2000,18.0,81.98809312244536,0 +FGD-2000,20.0,79.89194952905633,0 +FGD-2000,22.0,77.93708903500978,0 +FGD-2000,24.0,75.98222854096322,0 +FGD-2000,26.0,73.9562822107695,0 +FGD-2000,28.0,71.98365025768616,0 +FGD-2000,30.0,69.99324684556602,0 +FGD-2000,32.0,67.9850719744091,0 +FGD-2000,34.0,65.99466856228896,0 +FGD-2000,36.0,63.98649369113204,0 +FGD-2000,38.0,61.99609027901191,0 +FGD-2000,40.0,59.987915407854985,0 +FGD-2000,42.0,57.997511995734854,0 +FGD-2000,44.0,55.98933712457793,0 +FGD-2000,46.0,53.9989337124578,0 +FGD-2000,48.0,51.99075884130087,0 +FGD-2000,50.0,49.98258397014395,0 +FGD-2000,52.0,47.99218055802381,0 +FGD-2000,54.0,45.984005686866894,0 +FGD-2000,56.0,43.993602274746756,0 +FGD-2000,58.0,41.98542740358984,0 +FGD-2000,60.0,39.995023991469694,0 +FGD-2000,62.0,37.986849120312776,0 +FGD-2000,64.0,35.996445708192645,0 +FGD-2000,66.0,33.98827083703572,0 +FGD-2000,68.0,31.997867424915583,0 +FGD-2000,70.0,29.989692553758662,0 +FGD-2000,72.0,27.999289141638528,0 +FGD-2000,74.0,25.991114270481606,0 +FGD-2000,76.0,23.982939399324685,0 +FGD-2000,78.0,21.992535987204548,0 +FGD-2000,80.0,20.179847165452284,0 +FGD-2000,82.0,18.544872934067886,0 +FGD-2000,84.0,17.460813932823886,0 +FGD-2000,86.0,17.19424204727208,0 +FGD-2000,88.0,17.19424204727208,0 +FGD-2000,90.0,17.19424204727208,0 +FGD-2000,92.0,17.19424204727208,0 +FGD-2000,94.0,17.19424204727208,0 +FGD-2000,96.0,17.158699129198506,0 +FGD-2000,98.0,16.986315976541672,0 +FGD-2000,100.0,16.83152656833126,0 +FGD-2000,102.0,16.803092233872402,0 +FGD-2000,104.0,16.789230495823706,0 +FGD-2000,106.0,16.766127599075887,0 +FGD-2000,108.0,16.737693264617022,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9b_occupied.csv new file mode 100644 index 0000000..1232316 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,146,0 +Random,4.0,265,0 +Random,6.0,378,0 +Random,8.0,478,0 +Random,10.0,563,0 +Random,12.0,637,0 +Random,14.0,701,0 +Random,16.0,763,0 +Random,18.0,814,0 +Random,20.0,865,0 +Random,22.0,877,0 +Random,24.0,891,0 +Random,26.0,906,0 +Random,28.0,1042,0 +Random,30.0,1046,0 +Random,32.0,1054,0 +Random,34.0,1061,0 +Random,36.0,1066,0 +Random,38.0,1068,0 +Random,40.0,1071,0 +Random,42.0,1076,0 +Random,44.0,1081,0 +Random,46.0,1082,0 +Random,48.0,1085,0 +Random,50.0,1094,0 +Random,52.0,1095,0 +Random,54.0,1095,0 +Random,56.0,1096,0 +Random,58.0,1097,0 +Random,60.0,1098,0 +Random,62.0,1098,0 +Random,64.0,1098,0 +Random,66.0,1098,0 +Random,68.0,1098,0 +Random,70.0,1098,0 +Random,72.0,1098,0 +Random,74.0,1098,0 +Random,76.0,1098,0 +Random,78.0,1098,0 +Random,80.0,1098,0 +Random,82.0,1099,0 +Random,84.0,1099,0 +Random,86.0,1100,0 +Random,88.0,1100,0 +Random,90.0,1100,0 +Random,92.0,1100,0 +Random,94.0,1100,0 +Random,96.0,1100,0 +Random,98.0,1100,0 +Random,100.0,1100,0 +Random,102.0,1100,0 +Random,104.0,1100,0 +Random,106.0,1100,0 +Random,108.0,1100,0 +Clustering,2.0,86,0 +Clustering,4.0,161,0 +Clustering,6.0,235,0 +Clustering,8.0,309,0 +Clustering,10.0,383,0 +Clustering,12.0,457,0 +Clustering,14.0,512,0 +Clustering,16.0,545,0 +Clustering,18.0,564,0 +Clustering,20.0,583,0 +Clustering,22.0,597,0 +Clustering,24.0,611,0 +Clustering,26.0,625,0 +Clustering,28.0,639,0 +Clustering,30.0,653,0 +Clustering,32.0,667,0 +Clustering,34.0,682,0 +Clustering,36.0,696,0 +Clustering,38.0,711,0 +Clustering,40.0,725,0 +Clustering,42.0,739,0 +Clustering,44.0,753,0 +Clustering,46.0,767,0 +Clustering,48.0,781,0 +Clustering,50.0,795,0 +Clustering,52.0,809,0 +Clustering,54.0,823,0 +Clustering,56.0,838,0 +Clustering,58.0,852,0 +Clustering,60.0,866,0 +Clustering,62.0,880,0 +Clustering,64.0,894,0 +Clustering,66.0,908,0 +Clustering,68.0,922,0 +Clustering,70.0,936,0 +Clustering,72.0,951,0 +Clustering,74.0,965,0 +Clustering,76.0,979,0 +Clustering,78.0,994,0 +Clustering,80.0,1008,0 +Clustering,82.0,1022,0 +Clustering,84.0,1037,0 +Clustering,86.0,1051,0 +Clustering,88.0,1065,0 +Clustering,90.0,1079,0 +Clustering,92.0,1093,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,84,0 +FGD-Full,4.0,152,0 +FGD-Full,6.0,182,0 +FGD-Full,8.0,208,0 +FGD-Full,10.0,227,0 +FGD-Full,12.0,245,0 +FGD-Full,14.0,264,0 +FGD-Full,16.0,282,0 +FGD-Full,18.0,301,0 +FGD-Full,20.0,320,0 +FGD-Full,22.0,334,0 +FGD-Full,24.0,347,0 +FGD-Full,26.0,362,0 +FGD-Full,28.0,524,0 +FGD-Full,30.0,541,0 +FGD-Full,32.0,555,0 +FGD-Full,34.0,570,0 +FGD-Full,36.0,585,0 +FGD-Full,38.0,601,0 +FGD-Full,40.0,619,0 +FGD-Full,42.0,633,0 +FGD-Full,44.0,649,0 +FGD-Full,46.0,661,0 +FGD-Full,48.0,675,0 +FGD-Full,50.0,689,0 +FGD-Full,52.0,704,0 +FGD-Full,54.0,720,0 +FGD-Full,56.0,775,0 +FGD-Full,58.0,831,0 +FGD-Full,60.0,887,0 +FGD-Full,62.0,943,0 +FGD-Full,64.0,999,0 +FGD-Full,66.0,1055,0 +FGD-Full,68.0,1078,0 +FGD-Full,70.0,1092,0 +FGD-Full,72.0,1100,0 +FGD-Full,74.0,1100,0 +FGD-Full,76.0,1100,0 +FGD-Full,78.0,1100,0 +FGD-Full,80.0,1100,0 +FGD-Full,82.0,1100,0 +FGD-Full,84.0,1100,0 +FGD-Full,86.0,1100,0 +FGD-Full,88.0,1100,0 +FGD-Full,90.0,1100,0 +FGD-Full,92.0,1100,0 +FGD-Full,94.0,1100,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,93,0 +FGD-2000,4.0,151,0 +FGD-2000,6.0,182,0 +FGD-2000,8.0,208,0 +FGD-2000,10.0,227,0 +FGD-2000,12.0,245,0 +FGD-2000,14.0,264,0 +FGD-2000,16.0,282,0 +FGD-2000,18.0,301,0 +FGD-2000,20.0,320,0 +FGD-2000,22.0,334,0 +FGD-2000,24.0,347,0 +FGD-2000,26.0,361,0 +FGD-2000,28.0,476,0 +FGD-2000,30.0,491,0 +FGD-2000,32.0,504,0 +FGD-2000,34.0,518,0 +FGD-2000,36.0,531,0 +FGD-2000,38.0,545,0 +FGD-2000,40.0,559,0 +FGD-2000,42.0,573,0 +FGD-2000,44.0,587,0 +FGD-2000,46.0,601,0 +FGD-2000,48.0,615,0 +FGD-2000,50.0,629,0 +FGD-2000,52.0,643,0 +FGD-2000,54.0,658,0 +FGD-2000,56.0,673,0 +FGD-2000,58.0,687,0 +FGD-2000,60.0,701,0 +FGD-2000,62.0,715,0 +FGD-2000,64.0,762,0 +FGD-2000,66.0,818,0 +FGD-2000,68.0,873,0 +FGD-2000,70.0,929,0 +FGD-2000,72.0,985,0 +FGD-2000,74.0,1041,0 +FGD-2000,76.0,1075,0 +FGD-2000,78.0,1089,0 +FGD-2000,80.0,1100,0 +FGD-2000,82.0,1100,0 +FGD-2000,84.0,1100,0 +FGD-2000,86.0,1100,0 +FGD-2000,88.0,1100,0 +FGD-2000,90.0,1100,0 +FGD-2000,92.0,1100,0 +FGD-2000,94.0,1100,0 +FGD-2000,96.0,1100,0 +FGD-2000,98.0,1100,0 +FGD-2000,100.0,1100,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9c_failed.csv new file mode 100644 index 0000000..7e7b65a --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9c_failed.csv @@ -0,0 +1,5 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,1,586.0,0 +Clustering,1,162.0,0 +FGD-Full,1,949.0,0 +FGD-2000,1,741.0,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9d_breakdown.csv new file mode 100644 index 0000000..d2e61de --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-24031-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,24.993128675709265,0 +Random,stranded,61.576006263698616,0 +Random,non_gpu,13.43086506059213,0 +Clustering,deficient,77.05087446860648,0 +Clustering,stranded,9.506334490505347,0 +Clustering,non_gpu,13.442791040888178,0 +FGD-Full,deficient,19.73908989138172,0 +FGD-Full,stranded,66.83933917724667,0 +FGD-Full,non_gpu,13.42157093137159,0 +FGD-2000,deficient,28.792800526099594,0 +FGD-2000,stranded,57.800816255862166,0 +FGD-2000,non_gpu,13.40638321803824,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-phased-31042-90/experiment_summary.log new file mode 100644 index 0000000..0e38252 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-31042-90/experiment_summary.log @@ -0,0 +1,29 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-phased-31042-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: phased +Tier order: [3, 1, 0, 4, 2] + Phase 0: Tier 3 - 3911 tasks (gpu range: 1.00-1.00) + Phase 1: Tier 1 - 1600 tasks (gpu range: 0.05-0.48) + Phase 2: Tier 0 - 1088 tasks (gpu range: 0.00-0.00) + Phase 3: Tier 4 - 75 tasks (gpu range: 2.00-8.00) + Phase 4: Tier 2 - 1478 tasks (gpu range: 0.55-0.81) +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 5 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 98.7 88.6 7127 1025 26.0 +Clustering 99.1 91.3 6898 1254 23.4 +FGD-Full 97.7 95.1 7334 818 95.3 +FGD-2000 97.8 95.8 7382 770 78.5 diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure7.png b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure7.png new file mode 100644 index 0000000..b267031 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure7_results.csv new file mode 100644 index 0000000..137943b --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.87256834904882,13.87256834904882,0 +Random,2.0,13.94907929961835,13.66895739436566,0 +Random,4.0,14.025141911167779,13.46184316015944,0 +Random,6.0,14.121618813353475,13.273368029825223,0 +Random,8.0,14.231447550633632,13.090807272450627,0 +Random,10.0,14.346303526828939,12.910908309909678,0 +Random,12.0,14.472993332697556,12.734279365591897,0 +Random,14.0,14.549735537293815,12.512203708008668,0 +Random,16.0,14.581183289816622,12.24643188691547,0 +Random,18.0,14.674875352693961,12.033032677684368,0 +Random,20.0,14.77620336904726,11.819387127080454,0 +Random,22.0,14.888780967495757,11.613090397430048,0 +Random,24.0,14.938040536632643,11.351530359808278,0 +Random,26.0,15.058330820817947,11.140542244013705,0 +Random,28.0,15.18688427650483,10.933369149479487,0 +Random,30.0,15.268288750410413,10.685360067374482,0 +Random,32.0,15.40677467890514,10.475621098541152,0 +Random,34.0,15.492003931760184,10.2224650077529,0 +Random,36.0,15.571773760369014,9.965160353845535,0 +Random,38.0,15.671289366711324,9.71413849495097,0 +Random,40.0,15.812855508374055,9.48715126999659,0 +Random,42.0,15.960198610705486,9.25504319650471,0 +Random,44.0,16.161263508414663,9.049962913633305,0 +Random,46.0,16.270582436019733,8.784437433912911,0 +Random,48.0,16.382621175116352,8.518846553828052,0 +Random,50.0,16.586038395267686,8.291545407124222,0 +Random,52.0,16.846127285283274,8.083267046430574,0 +Random,54.0,16.962777740700965,7.8016116568214136,0 +Random,56.0,17.152080173669905,7.54423288250098,0 +Random,58.0,17.350550085821702,7.286182664438721,0 +Random,60.0,17.60680405626424,7.040218433729259,0 +Random,62.0,17.98886520929277,6.834937589740171,0 +Random,64.0,18.338143180799303,6.599385097053241,0 +Random,66.0,18.803469828614325,6.392578244560015,0 +Random,68.0,19.328358412386784,6.182876335933217,0 +Random,70.0,21.84507219423652,6.552551111256815,0 +Random,72.0,26.61991773542749,7.452820046275532,0 +Random,74.0,31.082188840967063,8.08065101005193,0 +Random,76.0,34.82604497297832,8.358065120625282,0 +Random,78.0,38.968455076940685,8.572783106405677,0 +Random,80.0,44.783369312077774,8.953172052837202,0 +Random,82.0,63.33829176223777,12.15302769679275,0 +Random,84.0,64.15186170381594,12.12671978978405,0 +Random,86.0,65.7160495607027,12.0953968738277,0 +Random,88.0,66.64508185660264,12.053201866683363,0 +Random,90.0,73.81222636906726,12.043185539264366,0 +Random,92.0,82.90465160583148,11.866253137255484,0 +Random,94.0,94.54388886422268,11.649883814072517,0 +Random,96.0,98.73174338868135,11.347044330808641,0 +Random,98.0,98.72733298246087,11.283374416388945,0 +Random,100.0,98.72733298246087,11.283374416388945,0 +Random,102.0,98.72733298246087,11.283374416388945,0 +Random,104.0,98.72733298246087,11.283374416388945,0 +Random,106.0,98.72733298246087,11.283374416388945,0 +Random,108.0,98.72733298246087,11.283374416388945,0 +Clustering,0.0,13.87256834904882,13.87256834904882,0 +Clustering,2.0,14.156820643536246,13.872526928817997,0 +Clustering,4.0,14.256292087079354,13.68370953657643,0 +Clustering,6.0,14.083540078274481,13.237576590366757,0 +Clustering,8.0,13.838076356035867,12.72896449597328,0 +Clustering,10.0,13.765552643532683,12.388263477314645,0 +Clustering,12.0,13.741370534278058,12.09055011821764,0 +Clustering,14.0,13.733760452619423,11.810497037537832,0 +Clustering,16.0,13.689575384661323,11.497588993763891,0 +Clustering,18.0,14.01444721934729,11.491498039820222,0 +Clustering,20.0,14.018766192835939,11.213518150693897,0 +Clustering,22.0,14.265744542460554,11.127128629262373,0 +Clustering,24.0,14.2882175062952,10.857724907929319,0 +Clustering,26.0,14.312921180255836,10.589068930763291,0 +Clustering,28.0,14.37938971925413,10.352036209827347,0 +Clustering,30.0,14.407934117187299,10.083249431932394,0 +Clustering,32.0,14.459701120426423,9.831671669939844,0 +Clustering,34.0,14.56154106186595,9.608495106221483,0 +Clustering,36.0,14.597426731588753,9.341626739017434,0 +Clustering,38.0,14.684891870965311,9.102701767536344,0 +Clustering,40.0,14.701895472980093,8.820614735521733,0 +Clustering,42.0,14.746611049573774,8.551304754711076,0 +Clustering,44.0,14.82145877019575,8.29970083257274,0 +Clustering,46.0,14.959381850178946,8.076524268854387,0 +Clustering,48.0,15.067162900113054,7.8348176018714755,0 +Clustering,50.0,15.235773590092439,7.616532985414969,0 +Clustering,52.0,15.428997201322906,7.403286377034271,0 +Clustering,54.0,15.527637181040799,7.141554118452744,0 +Clustering,56.0,15.636839444493905,6.877763928402775,0 +Clustering,58.0,15.729457073952812,6.605421550693176,0 +Clustering,60.0,15.883764038817914,6.351247394231438,0 +Clustering,62.0,16.095053432857917,6.115376619770789,0 +Clustering,64.0,16.454257987133257,5.921427478931019,0 +Clustering,66.0,16.54522642710601,5.624847726151376,0 +Clustering,68.0,16.836604514229542,5.385798493977817,0 +Clustering,70.0,17.844095825667054,5.3524359586550805,0 +Clustering,72.0,21.832075561786883,6.112360376761872,0 +Clustering,74.0,26.564922261136875,6.906266061239474,0 +Clustering,76.0,32.4184536532382,7.780256039810827,0 +Clustering,78.0,38.91225532239406,8.560419559906096,0 +Clustering,80.0,46.368677886651916,9.27010980546791,0 +Clustering,82.0,51.20735155867501,9.17018376020004,0 +Clustering,84.0,55.93524950182849,8.90351595411369,0 +Clustering,86.0,61.76426571133622,8.645899558469043,0 +Clustering,88.0,70.30229380130163,8.366810043158996,0 +Clustering,90.0,85.46578035472258,8.537464925784526,0 +Clustering,92.0,99.06755536686087,8.689141865249777,0 +Clustering,94.0,99.0673859216229,8.677683285393405,0 +Clustering,96.0,99.0673859216229,8.677683285393405,0 +Clustering,98.0,99.06721602888203,8.666224705537031,0 +Clustering,100.0,99.06721602888203,8.666224705537031,0 +Clustering,102.0,99.06721602888203,8.666224705537031,0 +Clustering,104.0,99.06721602888203,8.666224705537031,0 +Clustering,106.0,99.06721602888203,8.666224705537031,0 +Clustering,108.0,99.06721602888203,8.666224705537031,0 +FGD-Full,0.0,13.87256834904882,13.87256834904882,0 +FGD-Full,2.0,13.678543918718026,13.403854837002166,0 +FGD-Full,4.0,13.64675452643063,13.098653136174129,0 +FGD-Full,6.0,13.633815326901857,12.814865694683478,0 +FGD-Full,8.0,13.61060256972235,12.519722569909877,0 +FGD-Full,10.0,13.591943147341054,12.232024186624328,0 +FGD-Full,12.0,13.577735507680803,11.946573395864165,0 +FGD-Full,14.0,13.551858053057153,11.654068085790575,0 +FGD-Full,16.0,13.55488316153052,11.384463803339832,0 +FGD-Full,18.0,13.559108622347852,11.118131719124397,0 +FGD-Full,20.0,13.561608487831348,10.847840732846791,0 +FGD-Full,22.0,13.564377533180744,10.580069840613165,0 +FGD-Full,24.0,13.569514927325574,10.311577364358298,0 +FGD-Full,26.0,13.5737643434367,10.042221603292516,0 +FGD-Full,28.0,13.582296766278965,9.778191611906182,0 +FGD-Full,30.0,13.590024675901336,9.510843642029403,0 +FGD-Full,32.0,13.595706664847171,9.244210716137422,0 +FGD-Full,34.0,13.60104024081098,8.97470453423337,0 +FGD-Full,36.0,13.606796471048874,8.707672666118178,0 +FGD-Full,38.0,13.618196637736139,8.441491002741007,0 +FGD-Full,40.0,13.621980649647142,8.172704224846056,0 +FGD-Full,42.0,13.630628839665038,7.904165968336062,0 +FGD-Full,44.0,13.64217132495899,7.639325012430385,0 +FGD-Full,46.0,13.652198905457197,7.370780215883947,0 +FGD-Full,48.0,13.665416887745204,7.105919639868931,0 +FGD-Full,50.0,13.68140593564081,6.839487275094652,0 +FGD-Full,52.0,13.698392578053944,6.5728914094092135,0 +FGD-Full,54.0,13.711766809294135,6.3063892842461735,0 +FGD-Full,56.0,13.729993755018228,6.039050034418005,0 +FGD-Full,58.0,13.747488991431055,5.773114712413645,0 +FGD-Full,60.0,13.764600370733781,5.503883212040343,0 +FGD-Full,62.0,13.790678236059255,5.239820520471778,0 +FGD-Full,64.0,13.817770993106246,4.972629511469726,0 +FGD-Full,66.0,13.840814385535225,4.705434142443377,0 +FGD-Full,68.0,13.872403500163513,4.4375913098088375,0 +FGD-Full,70.0,14.32065549418408,4.295560400898987,0 +FGD-Full,72.0,15.71367383618816,4.399381866275248,0 +FGD-Full,74.0,16.840501860315964,4.378141419306488,0 +FGD-Full,76.0,18.0872991451146,4.340855363518749,0 +FGD-Full,78.0,19.559214352934305,4.302888119334878,0 +FGD-Full,80.0,21.369057466171295,4.27214055218483,0 +FGD-Full,82.0,22.467781223325506,4.023517644059111,0 +FGD-Full,84.0,23.555982931351426,3.749533106798084,0 +FGD-Full,86.0,24.777424348843862,3.503625556404489,0 +FGD-Full,88.0,24.913423445773503,3.478581576839399,0 +FGD-Full,90.0,30.299871956224695,3.6944627953022495,0 +FGD-Full,92.0,38.54160555308908,3.927449195688868,0 +FGD-Full,94.0,50.97290219386078,4.179379400245517,0 +FGD-Full,96.0,71.92065300831489,4.460690936538452,0 +FGD-Full,98.0,97.65635733954777,4.746407884981853,0 +FGD-Full,100.0,97.65635733954777,4.746407884981853,0 +FGD-Full,102.0,97.65635733954777,4.746407884981853,0 +FGD-Full,104.0,97.65635733954777,4.746407884981853,0 +FGD-Full,106.0,97.65635733954777,4.746407884981853,0 +FGD-Full,108.0,97.65635733954777,4.746407884981853,0 +FGD-2000,0.0,13.87256834904882,13.87256834904882,0 +FGD-2000,2.0,13.697478236324418,13.422408920400361,0 +FGD-2000,4.0,13.705454538186531,13.154995550159136,0 +FGD-2000,6.0,13.717436396127136,12.893463852695294,0 +FGD-2000,8.0,13.728356550122564,12.628038653533746,0 +FGD-2000,10.0,13.741231956181615,12.36637615534098,0 +FGD-2000,12.0,13.756045754775542,12.10346233017482,0 +FGD-2000,14.0,13.76556726190796,11.837849649968476,0 +FGD-2000,16.0,13.778428853061348,11.572215169640646,0 +FGD-2000,18.0,13.789758247395653,11.307258673091086,0 +FGD-2000,20.0,13.800376167633829,11.038829417188532,0 +FGD-2000,22.0,13.81159429039182,10.772896275196322,0 +FGD-2000,24.0,13.827352794564588,10.507510316253452,0 +FGD-2000,26.0,13.841199882982355,10.240077325902885,0 +FGD-2000,28.0,13.861513979392726,9.979206172120122,0 +FGD-2000,30.0,13.879216421759999,9.71323160989708,0 +FGD-2000,32.0,13.898596555667037,9.450156463831897,0 +FGD-2000,34.0,13.918718334938001,9.184325782410664,0 +FGD-2000,36.0,13.935612150043283,8.918098338778366,0 +FGD-2000,38.0,13.962852308433257,8.655132193320632,0 +FGD-2000,40.0,13.980003453343729,8.387505181888827,0 +FGD-2000,42.0,14.006508878053042,8.12213230301885,0 +FGD-2000,44.0,14.035592856637797,7.859632680160955,0 +FGD-2000,46.0,14.067861229141299,7.595195026502802,0 +FGD-2000,48.0,14.102900998593295,7.333408267617554,0 +FGD-2000,50.0,14.140742005695481,7.069114494761221,0 +FGD-2000,52.0,14.182104823174432,6.804990762852491,0 +FGD-2000,54.0,14.22328065822018,6.54164747529302,0 +FGD-2000,56.0,14.269143842745349,6.276191755961389,0 +FGD-2000,58.0,14.319855666583686,6.013474131888618,0 +FGD-2000,60.0,14.37030858139783,5.746080381756729,0 +FGD-2000,62.0,14.435948503228138,5.484993406771238,0 +FGD-2000,64.0,14.509262288130415,5.221477898252016,0 +FGD-2000,66.0,14.577638050075192,4.955930618410137,0 +FGD-2000,68.0,14.667423127248904,4.691907167060251,0 +FGD-2000,70.0,14.977567768229067,4.49260489738856,0 +FGD-2000,72.0,15.676119001756994,4.388867580481244,0 +FGD-2000,74.0,16.454508317253953,4.277792015679335,0 +FGD-2000,76.0,17.196040239703432,4.126957977911407,0 +FGD-2000,78.0,18.270453673601626,4.0193699311447375,0 +FGD-2000,80.0,19.46126648454634,3.890731534468675,0 +FGD-2000,82.0,20.304423290171663,3.6361047202843735,0 +FGD-2000,84.0,21.13574513788741,3.3642907775196345,0 +FGD-2000,86.0,22.047828360240448,3.1176499146394363,0 +FGD-2000,88.0,22.135783237068104,3.090748564723593,0 +FGD-2000,90.0,26.78380537317563,3.2657488655652718,0 +FGD-2000,92.0,33.50400294645883,3.414109701350539,0 +FGD-2000,94.0,44.45393602358027,3.644875148960225,0 +FGD-2000,96.0,62.243777257888176,3.860507955038727,0 +FGD-2000,98.0,97.81241420830285,4.109094827563651,0 +FGD-2000,100.0,97.81241420830285,4.109094827563651,0 +FGD-2000,102.0,97.81241420830285,4.109094827563651,0 +FGD-2000,104.0,97.81241420830285,4.109094827563651,0 +FGD-2000,106.0,97.81241420830285,4.109094827563651,0 +FGD-2000,108.0,97.81241420830285,4.109094827563651,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9.png b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9.png new file mode 100644 index 0000000..028d342 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9a_unalloc.csv new file mode 100644 index 0000000..0adda20 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.99182512884308,0 +Random,4.0,95.98365025768616,0 +Random,6.0,93.99324684556602,0 +Random,8.0,91.9850719744091,0 +Random,10.0,89.99466856228896,0 +Random,12.0,87.98649369113204,0 +Random,14.0,85.99609027901191,0 +Random,16.0,83.98791540785498,0 +Random,18.0,81.99751199573485,0 +Random,20.0,79.98933712457793,0 +Random,22.0,77.9989337124578,0 +Random,24.0,75.99075884130087,0 +Random,26.0,73.98258397014395,0 +Random,28.0,71.9921805580238,0 +Random,30.0,69.9840056868669,0 +Random,32.0,67.99360227474676,0 +Random,34.0,65.98542740358984,0 +Random,36.0,63.9950239914697,0 +Random,38.0,61.98684912031278,0 +Random,40.0,59.996445708192645,0 +Random,42.0,57.988270837035714,0 +Random,44.0,55.99786742491558,0 +Random,46.0,53.98969255375866,0 +Random,48.0,51.99928914163853,0 +Random,50.0,49.99111427048161,0 +Random,52.0,47.982939399324685,0 +Random,54.0,45.99253598720455,0 +Random,56.0,43.98436111604763,0 +Random,58.0,41.99395770392749,0 +Random,60.0,39.985782832770575,0 +Random,62.0,37.99537942065044,0 +Random,64.0,35.98720454949351,0 +Random,66.0,33.99680113737338,0 +Random,68.0,31.988626266216457,0 +Random,70.0,29.99555713524079,0 +Random,72.0,27.997156566554075,0 +Random,74.0,25.99768971032517,0 +Random,76.0,23.99946685622884,0 +Random,78.0,21.99928914163847,0 +Random,80.0,19.99218055802378,0 +Random,82.0,19.18748889283808,0 +Random,84.0,18.903145548249483,0 +Random,86.0,18.40554469521945,0 +Random,88.0,18.085658432557285,0 +Random,90.0,16.315976541674054,0 +Random,92.0,14.313133108228174,0 +Random,94.0,12.322196552336944,0 +Random,96.0,11.4928025590901,0 +Random,98.0,11.42882530655767,0 +Random,100.0,11.42882530655767,0 +Random,102.0,11.42882530655767,0 +Random,104.0,11.42882530655767,0 +Random,106.0,11.42882530655767,0 +Random,108.0,11.42882530655767,0 +Clustering,2.0,97.99182512884308,0 +Clustering,4.0,95.98365025768616,0 +Clustering,6.0,93.99324684556602,0 +Clustering,8.0,91.9850719744091,0 +Clustering,10.0,89.99466856228896,0 +Clustering,12.0,87.98649369113204,0 +Clustering,14.0,85.99609027901191,0 +Clustering,16.0,83.98791540785498,0 +Clustering,18.0,81.99751199573485,0 +Clustering,20.0,79.98933712457793,0 +Clustering,22.0,77.9989337124578,0 +Clustering,24.0,75.99075884130087,0 +Clustering,26.0,73.98258397014395,0 +Clustering,28.0,71.9921805580238,0 +Clustering,30.0,69.9840056868669,0 +Clustering,32.0,67.99360227474676,0 +Clustering,34.0,65.98542740358984,0 +Clustering,36.0,63.9950239914697,0 +Clustering,38.0,61.98684912031278,0 +Clustering,40.0,59.996445708192645,0 +Clustering,42.0,57.988270837035714,0 +Clustering,44.0,55.99786742491558,0 +Clustering,46.0,53.98969255375866,0 +Clustering,48.0,51.99928914163853,0 +Clustering,50.0,49.99111427048161,0 +Clustering,52.0,47.982939399324685,0 +Clustering,54.0,45.99253598720455,0 +Clustering,56.0,43.98436111604763,0 +Clustering,58.0,41.99395770392749,0 +Clustering,60.0,39.985782832770575,0 +Clustering,62.0,37.99537942065044,0 +Clustering,64.0,35.98720454949351,0 +Clustering,66.0,33.99680113737338,0 +Clustering,68.0,31.988626266216457,0 +Clustering,70.0,29.9955571352408,0 +Clustering,72.0,27.997156566554114,0 +Clustering,74.0,25.99768971032522,0 +Clustering,76.0,23.999466856228896,0 +Clustering,78.0,21.99928914163853,0 +Clustering,80.0,19.99218055802381,0 +Clustering,82.0,17.907943842189443,0 +Clustering,84.0,15.917540430069305,0 +Clustering,86.0,13.998222854096317,0 +Clustering,88.0,11.901190687755461,0 +Clustering,90.0,9.989337124577922,0 +Clustering,92.0,8.770925893015812,0 +Clustering,94.0,8.759374444641901,0 +Clustering,96.0,8.759374444641901,0 +Clustering,98.0,8.74782299626799,0 +Clustering,100.0,8.74782299626799,0 +Clustering,102.0,8.74782299626799,0 +Clustering,104.0,8.74782299626799,0 +Clustering,106.0,8.74782299626799,0 +Clustering,108.0,8.74782299626799,0 +FGD-Full,2.0,97.99182512884308,0 +FGD-Full,4.0,95.98365025768616,0 +FGD-Full,6.0,93.99324684556602,0 +FGD-Full,8.0,91.9850719744091,0 +FGD-Full,10.0,89.99466856228896,0 +FGD-Full,12.0,87.98649369113204,0 +FGD-Full,14.0,85.99609027901191,0 +FGD-Full,16.0,83.98791540785498,0 +FGD-Full,18.0,81.99751199573485,0 +FGD-Full,20.0,79.98933712457793,0 +FGD-Full,22.0,77.9989337124578,0 +FGD-Full,24.0,75.99075884130087,0 +FGD-Full,26.0,73.98258397014395,0 +FGD-Full,28.0,71.9921805580238,0 +FGD-Full,30.0,69.9840056868669,0 +FGD-Full,32.0,67.99360227474676,0 +FGD-Full,34.0,65.98542740358984,0 +FGD-Full,36.0,63.9950239914697,0 +FGD-Full,38.0,61.98684912031278,0 +FGD-Full,40.0,59.996445708192645,0 +FGD-Full,42.0,57.988270837035714,0 +FGD-Full,44.0,55.99786742491558,0 +FGD-Full,46.0,53.98969255375866,0 +FGD-Full,48.0,51.99928914163853,0 +FGD-Full,50.0,49.99111427048161,0 +FGD-Full,52.0,47.982939399324685,0 +FGD-Full,54.0,45.99253598720455,0 +FGD-Full,56.0,43.98436111604763,0 +FGD-Full,58.0,41.99395770392749,0 +FGD-Full,60.0,39.985782832770575,0 +FGD-Full,62.0,37.99537942065044,0 +FGD-Full,64.0,35.98720454949351,0 +FGD-Full,66.0,33.99680113737338,0 +FGD-Full,68.0,31.988626266216457,0 +FGD-Full,70.0,29.9955571352408,0 +FGD-Full,72.0,27.99715656655411,0 +FGD-Full,74.0,25.997689710325204,0 +FGD-Full,76.0,23.999466856228892,0 +FGD-Full,78.0,21.999289141638513,0 +FGD-Full,80.0,19.992180558023794,0 +FGD-Full,82.0,17.90794384218942,0 +FGD-Full,84.0,15.917540430069291,0 +FGD-Full,86.0,14.140394526390597,0 +FGD-Full,88.0,13.96267993602273,0 +FGD-Full,90.0,12.192998045139504,0 +FGD-Full,92.0,10.190154611693615,0 +FGD-Full,94.0,8.199218055802374,0 +FGD-Full,96.0,6.202239203838629,0 +FGD-Full,98.0,4.860316331970848,0 +FGD-Full,100.0,4.860316331970848,0 +FGD-Full,102.0,4.860316331970848,0 +FGD-Full,104.0,4.860316331970848,0 +FGD-Full,106.0,4.860316331970848,0 +FGD-Full,108.0,4.860316331970848,0 +FGD-2000,2.0,97.99182512884308,0 +FGD-2000,4.0,95.98365025768616,0 +FGD-2000,6.0,93.99324684556602,0 +FGD-2000,8.0,91.9850719744091,0 +FGD-2000,10.0,89.99466856228896,0 +FGD-2000,12.0,87.98649369113204,0 +FGD-2000,14.0,85.99609027901191,0 +FGD-2000,16.0,83.98791540785498,0 +FGD-2000,18.0,81.99751199573485,0 +FGD-2000,20.0,79.98933712457793,0 +FGD-2000,22.0,77.9989337124578,0 +FGD-2000,24.0,75.99075884130087,0 +FGD-2000,26.0,73.98258397014395,0 +FGD-2000,28.0,71.9921805580238,0 +FGD-2000,30.0,69.9840056868669,0 +FGD-2000,32.0,67.99360227474676,0 +FGD-2000,34.0,65.98542740358984,0 +FGD-2000,36.0,63.9950239914697,0 +FGD-2000,38.0,61.98684912031278,0 +FGD-2000,40.0,59.996445708192645,0 +FGD-2000,42.0,57.988270837035714,0 +FGD-2000,44.0,55.99786742491558,0 +FGD-2000,46.0,53.98969255375866,0 +FGD-2000,48.0,51.99928914163853,0 +FGD-2000,50.0,49.99111427048161,0 +FGD-2000,52.0,47.982939399324685,0 +FGD-2000,54.0,45.99253598720455,0 +FGD-2000,56.0,43.98436111604763,0 +FGD-2000,58.0,41.99395770392749,0 +FGD-2000,60.0,39.985782832770575,0 +FGD-2000,62.0,37.99537942065044,0 +FGD-2000,64.0,35.98720454949351,0 +FGD-2000,66.0,33.99680113737338,0 +FGD-2000,68.0,31.988626266216457,0 +FGD-2000,70.0,29.9955571352408,0 +FGD-2000,72.0,27.997156566554104,0 +FGD-2000,74.0,25.9976897103252,0 +FGD-2000,76.0,23.999466856228885,0 +FGD-2000,78.0,21.999289141638513,0 +FGD-2000,80.0,19.992180558023804,0 +FGD-2000,82.0,17.907943842189436,0 +FGD-2000,84.0,15.917540430069298,0 +FGD-2000,86.0,14.140394526390606,0 +FGD-2000,88.0,13.962679936022738,0 +FGD-2000,90.0,12.192998045139495,0 +FGD-2000,92.0,10.190154611693611,0 +FGD-2000,94.0,8.199218055802364,0 +FGD-2000,96.0,6.202239203838619,0 +FGD-2000,98.0,4.200995201706053,0 +FGD-2000,100.0,4.200995201706053,0 +FGD-2000,102.0,4.200995201706053,0 +FGD-2000,104.0,4.200995201706053,0 +FGD-2000,106.0,4.200995201706053,0 +FGD-2000,108.0,4.200995201706053,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9b_occupied.csv new file mode 100644 index 0000000..4255652 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,109,0 +Random,4.0,203,0 +Random,6.0,294,0 +Random,8.0,372,0 +Random,10.0,444,0 +Random,12.0,508,0 +Random,14.0,577,0 +Random,16.0,637,0 +Random,18.0,691,0 +Random,20.0,735,0 +Random,22.0,784,0 +Random,24.0,817,0 +Random,26.0,852,0 +Random,28.0,886,0 +Random,30.0,912,0 +Random,32.0,936,0 +Random,34.0,956,0 +Random,36.0,969,0 +Random,38.0,986,0 +Random,40.0,1006,0 +Random,42.0,1026,0 +Random,44.0,1039,0 +Random,46.0,1045,0 +Random,48.0,1051,0 +Random,50.0,1056,0 +Random,52.0,1066,0 +Random,54.0,1070,0 +Random,56.0,1072,0 +Random,58.0,1074,0 +Random,60.0,1080,0 +Random,62.0,1080,0 +Random,64.0,1081,0 +Random,66.0,1083,0 +Random,68.0,1084,0 +Random,70.0,1087,0 +Random,72.0,1091,0 +Random,74.0,1095,0 +Random,76.0,1097,0 +Random,78.0,1099,0 +Random,80.0,1100,0 +Random,82.0,1100,0 +Random,84.0,1100,0 +Random,86.0,1100,0 +Random,88.0,1100,0 +Random,90.0,1100,0 +Random,92.0,1100,0 +Random,94.0,1100,0 +Random,96.0,1100,0 +Random,98.0,1100,0 +Random,100.0,1100,0 +Random,102.0,1100,0 +Random,104.0,1100,0 +Random,106.0,1100,0 +Random,108.0,1100,0 +Clustering,2.0,80,0 +Clustering,4.0,146,0 +Clustering,6.0,194,0 +Clustering,8.0,244,0 +Clustering,10.0,302,0 +Clustering,12.0,358,0 +Clustering,14.0,414,0 +Clustering,16.0,469,0 +Clustering,18.0,513,0 +Clustering,20.0,541,0 +Clustering,22.0,557,0 +Clustering,24.0,571,0 +Clustering,26.0,586,0 +Clustering,28.0,600,0 +Clustering,30.0,614,0 +Clustering,32.0,628,0 +Clustering,34.0,643,0 +Clustering,36.0,657,0 +Clustering,38.0,671,0 +Clustering,40.0,685,0 +Clustering,42.0,699,0 +Clustering,44.0,713,0 +Clustering,46.0,728,0 +Clustering,48.0,742,0 +Clustering,50.0,756,0 +Clustering,52.0,771,0 +Clustering,54.0,785,0 +Clustering,56.0,799,0 +Clustering,58.0,813,0 +Clustering,60.0,827,0 +Clustering,62.0,842,0 +Clustering,64.0,856,0 +Clustering,66.0,870,0 +Clustering,68.0,884,0 +Clustering,70.0,901,0 +Clustering,72.0,923,0 +Clustering,74.0,946,0 +Clustering,76.0,969,0 +Clustering,78.0,992,0 +Clustering,80.0,1014,0 +Clustering,82.0,1030,0 +Clustering,84.0,1044,0 +Clustering,86.0,1057,0 +Clustering,88.0,1072,0 +Clustering,90.0,1089,0 +Clustering,92.0,1100,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,65,0 +FGD-Full,4.0,105,0 +FGD-Full,6.0,138,0 +FGD-Full,8.0,174,0 +FGD-Full,10.0,207,0 +FGD-Full,12.0,240,0 +FGD-Full,14.0,274,0 +FGD-Full,16.0,291,0 +FGD-Full,18.0,305,0 +FGD-Full,20.0,318,0 +FGD-Full,22.0,331,0 +FGD-Full,24.0,346,0 +FGD-Full,26.0,360,0 +FGD-Full,28.0,377,0 +FGD-Full,30.0,393,0 +FGD-Full,32.0,407,0 +FGD-Full,34.0,421,0 +FGD-Full,36.0,435,0 +FGD-Full,38.0,452,0 +FGD-Full,40.0,464,0 +FGD-Full,42.0,479,0 +FGD-Full,44.0,495,0 +FGD-Full,46.0,510,0 +FGD-Full,48.0,526,0 +FGD-Full,50.0,543,0 +FGD-Full,52.0,560,0 +FGD-Full,54.0,574,0 +FGD-Full,56.0,590,0 +FGD-Full,58.0,605,0 +FGD-Full,60.0,619,0 +FGD-Full,62.0,636,0 +FGD-Full,64.0,652,0 +FGD-Full,66.0,666,0 +FGD-Full,68.0,681,0 +FGD-Full,70.0,697,0 +FGD-Full,72.0,722,0 +FGD-Full,74.0,774,0 +FGD-Full,76.0,827,0 +FGD-Full,78.0,882,0 +FGD-Full,80.0,935,0 +FGD-Full,82.0,968,0 +FGD-Full,84.0,981,0 +FGD-Full,86.0,992,0 +FGD-Full,88.0,993,0 +FGD-Full,90.0,1003,0 +FGD-Full,92.0,1012,0 +FGD-Full,94.0,1047,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,79,0 +FGD-2000,4.0,105,0 +FGD-2000,6.0,121,0 +FGD-2000,8.0,137,0 +FGD-2000,10.0,153,0 +FGD-2000,12.0,170,0 +FGD-2000,14.0,184,0 +FGD-2000,16.0,200,0 +FGD-2000,18.0,214,0 +FGD-2000,20.0,229,0 +FGD-2000,22.0,243,0 +FGD-2000,24.0,259,0 +FGD-2000,26.0,274,0 +FGD-2000,28.0,290,0 +FGD-2000,30.0,306,0 +FGD-2000,32.0,321,0 +FGD-2000,34.0,337,0 +FGD-2000,36.0,351,0 +FGD-2000,38.0,368,0 +FGD-2000,40.0,381,0 +FGD-2000,42.0,397,0 +FGD-2000,44.0,413,0 +FGD-2000,46.0,429,0 +FGD-2000,48.0,445,0 +FGD-2000,50.0,461,0 +FGD-2000,52.0,478,0 +FGD-2000,54.0,493,0 +FGD-2000,56.0,509,0 +FGD-2000,58.0,524,0 +FGD-2000,60.0,539,0 +FGD-2000,62.0,555,0 +FGD-2000,64.0,572,0 +FGD-2000,66.0,587,0 +FGD-2000,68.0,603,0 +FGD-2000,70.0,625,0 +FGD-2000,72.0,687,0 +FGD-2000,74.0,747,0 +FGD-2000,76.0,807,0 +FGD-2000,78.0,867,0 +FGD-2000,80.0,926,0 +FGD-2000,82.0,950,0 +FGD-2000,84.0,966,0 +FGD-2000,86.0,977,0 +FGD-2000,88.0,977,0 +FGD-2000,90.0,1041,0 +FGD-2000,92.0,1100,0 +FGD-2000,94.0,1100,0 +FGD-2000,96.0,1100,0 +FGD-2000,98.0,1100,0 +FGD-2000,100.0,1100,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9c_failed.csv new file mode 100644 index 0000000..45fab88 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9c_failed.csv @@ -0,0 +1,6 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,8,356.0,0 +Random,<1,65.70000000000006,0 +Clustering,<1,267.8900000000007,0 +FGD-Full,8,124.0,0 +FGD-2000,8,124.0,0 diff --git a/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9d_breakdown.csv new file mode 100644 index 0000000..f976aae --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-phased-31042-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,28.38585776230295,0 +Random,stranded,58.095679159909395,0 +Random,non_gpu,13.51846307778764,0 +Clustering,deficient,11.467010318500206,0 +Clustering,stranded,75.06090618918932,0 +Clustering,non_gpu,13.472083492310466,0 +FGD-Full,deficient,66.85370338203379,0 +FGD-Full,stranded,19.479579549548816,0 +FGD-Full,non_gpu,13.666717068417396,0 +FGD-2000,deficient,83.2091646380935,0 +FGD-2000,stranded,3.1459231440206703,0 +FGD-2000,non_gpu,13.644912217885835,0 diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/experiment_summary.log b/standalone_fgd_replication/result/dist-shift-trace-90/experiment_summary.log new file mode 100644 index 0000000..9d6e0e7 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-trace-90/experiment_summary.log @@ -0,0 +1,23 @@ +Experiment: Distribution-Shift - Trace Replay +Result: dist-shift-trace-90 +Mode: replay +FGD popularity threshold: 95 +Figure9 sample interval (%): 2.0 +Figure9 max arrival (%): 120.0 +Figure9 snapshot (%): 96.0 +Task order: trace +Cluster: 1213 nodes -> 1100 nodes (90.0%) +Full distribution: 55 task types +FGD scoring distribution (top 95%): 21 task types +First-2000 distribution (FGD-2000, top 95%): 20 task types + +============================================================================ +EXPERIMENT SUMMARY +============================================================================ + +Scheduler Avg Frag% Avg Alloc% Scheduled Failed Time(s) +---------------------------------------------------------------------------- +Random 99.2 87.1 6948 1204 14.5 +Clustering 99.3 92.4 7112 1040 13.5 +FGD-Full 99.4 87.5 6828 1324 65.3 +FGD-2000 99.5 88.6 6900 1252 63.4 diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure7.png b/standalone_fgd_replication/result/dist-shift-trace-90/figure7.png new file mode 100644 index 0000000..b09b8f5 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-trace-90/figure7.png differ diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure7_results.csv b/standalone_fgd_replication/result/dist-shift-trace-90/figure7_results.csv new file mode 100644 index 0000000..224ef08 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-trace-90/figure7_results.csv @@ -0,0 +1,221 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,0.0,13.872568349048816,13.872568349048816,0 +Random,2.0,14.300834803983467,14.012734104964528,0 +Random,4.0,14.693568581885144,14.105277473690203,0 +Random,6.0,15.168737326969705,14.25640260848034,0 +Random,8.0,15.666846628920952,14.410965251827045,0 +Random,10.0,16.150689578896102,14.534702152788029,0 +Random,12.0,16.497809335292345,14.516606264343265,0 +Random,14.0,16.83484316149491,14.47754626726972,0 +Random,16.0,17.22051261210382,14.464067666356184,0 +Random,18.0,17.521549921758734,14.366425401815375,0 +Random,20.0,17.813870687727054,14.251064892334325,0 +Random,22.0,18.429023806466024,14.373492281797681,0 +Random,24.0,18.85262565615603,14.32605227442401,0 +Random,26.0,19.274211272531858,14.259628045455063,0 +Random,28.0,19.781692597986975,14.242291346241116,0 +Random,30.0,20.291544900672957,14.20184564624532,0 +Random,32.0,20.70943431477585,14.078808572784322,0 +Random,34.0,21.10522821068095,13.92735022313724,0 +Random,36.0,21.69325604800566,13.88337545407466,0 +Random,38.0,22.38942546104824,13.881045893092491,0 +Random,40.0,22.97170057350221,13.779754419015372,0 +Random,42.0,23.82255579016012,13.8020106862451,0 +Random,44.0,24.65239276590909,13.804770407224467,0 +Random,46.0,25.584959055481725,13.814968525856546,0 +Random,48.0,26.551120183022253,13.801958344153418,0 +Random,50.0,27.608009795159695,13.803268945657141,0 +Random,52.0,28.524301524245278,13.688268377981966,0 +Random,54.0,29.59716585539301,13.613276134465194,0 +Random,56.0,31.156128987856807,13.706980316059864,0 +Random,58.0,32.899682766830196,13.807634943187978,0 +Random,60.0,34.29489634075611,13.764156388490687,0 +Random,62.0,36.13551223705601,13.812088337405845,0 +Random,64.0,38.32817862938121,13.955829989049326,0 +Random,66.0,40.471880870954365,13.988439962378177,0 +Random,68.0,42.95788814480825,14.050825152038366,0 +Random,70.0,46.11134526383806,14.223879072633238,0 +Random,72.0,49.58534110936404,14.298237564818239,0 +Random,74.0,53.210523788253084,14.361545902422945,0 +Random,76.0,57.231435378714856,14.382411256501404,0 +Random,78.0,62.710476436065306,14.50833117802794,0 +Random,80.0,69.6824382811579,14.722721529782499,0 +Random,82.0,77.2696106720421,14.782705043658614,0 +Random,84.0,86.23579589847324,14.889199421930485,0 +Random,86.0,91.7541522028224,14.684251683797733,0 +Random,88.0,94.11403080342113,14.334368039766163,0 +Random,90.0,96.90426687945794,13.975603287841956,0 +Random,92.0,98.67120968783628,13.388211941827466,0 +Random,94.0,98.89441418157176,13.213397443421226,0 +Random,96.0,98.94248275549077,13.135067361503344,0 +Random,98.0,98.95834989544096,13.112377053854797,0 +Random,100.0,98.96278029246237,13.101708336000167,0 +Random,102.0,98.97548156665155,13.077533461878426,0 +Random,104.0,98.99843459608691,13.046258963991905,0 +Random,106.0,99.09568260246355,12.932981586919738,0 +Random,108.0,99.18456945584157,12.803569852734025,0 +Clustering,0.0,13.872568349048816,13.872568349048816,0 +Clustering,2.0,14.119648896572803,13.835198319193118,0 +Clustering,4.0,14.256766319967776,13.685963603737894,0 +Clustering,6.0,14.28918367678745,13.429750351112679,0 +Clustering,8.0,14.382212201782052,13.229309330294955,0 +Clustering,10.0,14.459056059971545,13.012328186702431,0 +Clustering,12.0,14.490398181651305,12.750262822264572,0 +Clustering,14.0,14.582605424807424,12.540677849489427,0 +Clustering,16.0,14.704053235235055,12.350411730174397,0 +Clustering,18.0,15.137675948454302,12.411818203380388,0 +Clustering,20.0,15.327207137874325,12.261738471616065,0 +Clustering,22.0,15.62741113897802,12.188408661763699,0 +Clustering,24.0,15.871647655613755,12.060816256716747,0 +Clustering,26.0,16.0221132895666,11.853630365511213,0 +Clustering,28.0,16.12054725752044,11.606364296946868,0 +Clustering,30.0,16.21823179899397,11.350975285114984,0 +Clustering,32.0,16.33116611078606,11.102348714568834,0 +Clustering,34.0,16.593665494115292,10.950167821695151,0 +Clustering,36.0,16.820321934722948,10.764766900892903,0 +Clustering,38.0,17.17978555975705,10.651161737194048,0 +Clustering,40.0,17.640020078600056,10.58150413600617,0 +Clustering,42.0,17.96059766735618,10.405783624550908,0 +Clustering,44.0,18.468999381196557,10.342212966084347,0 +Clustering,46.0,18.997703269007907,10.258084531453408,0 +Clustering,48.0,19.429922851971973,10.100175961860534,0 +Clustering,50.0,19.96799885475225,9.983467136665599,0 +Clustering,52.0,20.370916999351987,9.775614619545097,0 +Clustering,54.0,21.06931702971653,9.690874865907398,0 +Clustering,56.0,21.63714490226146,9.51915173372872,0 +Clustering,58.0,22.47485534988319,9.432449554954816,0 +Clustering,60.0,23.02659808774969,9.20892052687224,0 +Clustering,62.0,23.784633275883813,9.023577921394963,0 +Clustering,64.0,24.541440291059992,8.831211338574475,0 +Clustering,66.0,25.462905772608753,8.656030423726275,0 +Clustering,68.0,26.91446970215159,8.611960671534362,0 +Clustering,70.0,28.103997968388633,8.429451318846247,0 +Clustering,72.0,29.51057973918813,8.257822755594587,0 +Clustering,74.0,31.66815626797864,8.232088540582955,0 +Clustering,76.0,33.846040141611184,8.120643659922926,0 +Clustering,78.0,36.55505794404486,8.04139814730354,0 +Clustering,80.0,40.75822840677951,8.147951582104524,0 +Clustering,82.0,45.236360709936875,8.139811612942106,0 +Clustering,84.0,50.574073810225265,8.084841364003905,0 +Clustering,86.0,57.85476964915984,8.097200158076996,0 +Clustering,88.0,66.71752312544226,8.003731439594526,0 +Clustering,90.0,78.09040785298332,7.806681558474951,0 +Clustering,92.0,96.0243463869392,7.679729270395244,0 +Clustering,94.0,99.29762041206001,7.636405234959061,0 +Clustering,96.0,99.34074771238677,7.599293558343109,0 +Clustering,98.0,99.34074771238677,7.599293558343109,0 +Clustering,100.0,99.3404573132356,7.587972624453809,0 +Clustering,102.0,99.34116692388503,7.582377427072892,0 +Clustering,104.0,99.34207334370194,7.5739724338335455,0 +Clustering,106.0,99.34207334370194,7.5739724338335455,0 +Clustering,108.0,99.3419978470783,7.556312155416345,0 +FGD-Full,0.0,13.872568349048816,13.872568349048816,0 +FGD-Full,2.0,13.841369496075387,13.562525059239574,0 +FGD-Full,4.0,13.900224211883948,13.343696486151705,0 +FGD-Full,6.0,13.926353090611215,13.08874247394399,0 +FGD-Full,8.0,14.053938526276385,12.927350637339567,0 +FGD-Full,10.0,14.152764595191769,12.736683286788558,0 +FGD-Full,12.0,14.21407608551668,12.507123930900182,0 +FGD-Full,14.0,14.316821782634987,12.312110529929503,0 +FGD-Full,16.0,14.450044140489796,12.137061244214843,0 +FGD-Full,18.0,14.552662839617364,11.932149040280116,0 +FGD-Full,20.0,14.66033127459716,11.728238966130057,0 +FGD-Full,22.0,14.883797461131515,11.60843624589346,0 +FGD-Full,24.0,15.108188275577609,11.480665821054435,0 +FGD-Full,26.0,15.261236359282382,11.290711247275587,0 +FGD-Full,28.0,15.37174261636634,11.067244916342418,0 +FGD-Full,30.0,15.475587349854308,10.831205997544734,0 +FGD-Full,32.0,15.570420268971422,10.58517403385781,0 +FGD-Full,34.0,15.69156004354692,10.354868002008358,0 +FGD-Full,36.0,15.86875580918011,10.15577810912021,0 +FGD-Full,38.0,16.027351691800877,9.936673219492485,0 +FGD-Full,40.0,16.20479422116826,9.720572670007344,0 +FGD-Full,42.0,16.619031204874272,9.628523837037607,0 +FGD-Full,44.0,17.102208552110024,9.576841678623275,0 +FGD-Full,46.0,17.581518934593593,9.49339532619344,0 +FGD-Full,48.0,17.83317264448111,9.270143944458132,0 +FGD-Full,50.0,18.316729635459943,9.157876545214368,0 +FGD-Full,52.0,18.6385613141954,8.944290160140163,0 +FGD-Full,54.0,19.216636225150562,8.838730592877809,0 +FGD-Full,56.0,19.688255953170366,8.661747963389013,0 +FGD-Full,58.0,20.37261172915874,8.550161033137375,0 +FGD-Full,60.0,20.896574551696396,8.357070097680214,0 +FGD-Full,62.0,21.46826541421042,8.144778334620682,0 +FGD-Full,64.0,22.13371111969465,7.964792542195864,0 +FGD-Full,66.0,22.860161167051015,7.771236021544086,0 +FGD-Full,68.0,23.78890793065599,7.611858668765974,0 +FGD-Full,70.0,24.465801453613686,7.338218660624937,0 +FGD-Full,72.0,25.558854496968674,7.152027921421178,0 +FGD-Full,74.0,26.60351345599501,6.915542427134816,0 +FGD-Full,76.0,28.093588166097888,6.740464103658339,0 +FGD-Full,78.0,29.595495522622073,6.510430464326874,0 +FGD-Full,80.0,31.176739701889026,6.232522253999997,0 +FGD-Full,82.0,33.05377335717547,5.947681997442213,0 +FGD-Full,84.0,42.147202551006195,6.797631456040552,0 +FGD-Full,86.0,64.60932863499029,9.42145699629553,0 +FGD-Full,88.0,92.35554413980805,12.17904886680348,0 +FGD-Full,90.0,98.64644373353293,12.439058850387118,0 +FGD-Full,92.0,99.41126062890943,12.46589294692817,0 +FGD-Full,94.0,99.41165582525878,12.460289094899021,0 +FGD-Full,96.0,99.411677614661,12.45463841620892,0 +FGD-Full,98.0,99.411677614661,12.45463841620892,0 +FGD-Full,100.0,99.41225628621301,12.443404028801925,0 +FGD-Full,102.0,99.41498211723273,12.43809162259695,0 +FGD-Full,104.0,99.41739980189865,12.429913503221925,0 +FGD-Full,106.0,99.41739980189865,12.429913503221925,0 +FGD-Full,108.0,99.4174610279649,12.41225322480473,0 +FGD-2000,0.0,13.872568349048816,13.872568349048816,0 +FGD-2000,2.0,13.849483506615002,13.57047560714639,0 +FGD-2000,4.0,13.888787855023097,13.332718010370858,0 +FGD-2000,6.0,13.945942701800487,13.107153853746931,0 +FGD-2000,8.0,14.055203084523052,12.928513826421787,0 +FGD-2000,10.0,14.138121739462203,12.72350554935166,0 +FGD-2000,12.0,14.206264759156785,12.500250657796805,0 +FGD-2000,14.0,14.308012529620258,12.304534791511427,0 +FGD-2000,16.0,14.438724373791448,12.127553404629555,0 +FGD-2000,18.0,14.526696564151385,11.910858540232416,0 +FGD-2000,20.0,14.630630886605802,11.704478708518893,0 +FGD-2000,22.0,14.831260456828863,11.567460650344659,0 +FGD-2000,24.0,15.071149091043587,11.452519858602615,0 +FGD-2000,26.0,15.20239719887235,11.247180306886364,0 +FGD-2000,28.0,15.315203331048115,11.026538138091686,0 +FGD-2000,30.0,15.414338863232727,10.788338805454448,0 +FGD-2000,32.0,15.509694936321397,10.543891383597858,0 +FGD-2000,34.0,15.688312987352052,10.352725268067333,0 +FGD-2000,36.0,15.914132952574795,10.184818835758369,0 +FGD-2000,38.0,16.060462348935125,9.95720123849103,0 +FGD-2000,40.0,16.25770878723459,9.7523138866948,0 +FGD-2000,42.0,16.68048222841495,9.66412655284442,0 +FGD-2000,44.0,17.142405313362193,9.599350936262864,0 +FGD-2000,46.0,17.646515067062072,9.528490927574207,0 +FGD-2000,48.0,17.90906156193884,9.30959296469963,0 +FGD-2000,50.0,18.401219944030608,9.200119447225612,0 +FGD-2000,52.0,18.709791260343987,8.978472053029016,0 +FGD-2000,54.0,19.28084570241689,8.868263871460865,0 +FGD-2000,56.0,19.799453418768863,8.710668722214617,0 +FGD-2000,58.0,20.44955492947869,8.58245324789543,0 +FGD-2000,60.0,20.9624634347001,8.383420732927036,0 +FGD-2000,62.0,21.53026275894888,8.168299314098396,0 +FGD-2000,64.0,22.201153266588207,7.989061527442064,0 +FGD-2000,66.0,23.053588390260046,7.836990964983236,0 +FGD-2000,68.0,24.019764300560876,7.685726963419208,0 +FGD-2000,70.0,24.715203315933657,7.4130237064985005,0 +FGD-2000,72.0,25.836420297620634,7.229698004661017,0 +FGD-2000,74.0,26.904739076387962,6.993845564102544,0 +FGD-2000,76.0,28.41984504723702,6.81874256288854,0 +FGD-2000,78.0,29.957048279358787,6.5899650029569505,0 +FGD-2000,80.0,31.539450774866147,6.305031594480049,0 +FGD-2000,82.0,33.45774713152649,6.0203728675338954,0 +FGD-2000,84.0,36.646739258666784,5.910499688432645,0 +FGD-2000,86.0,53.270951371355935,7.692336738454163,0 +FGD-2000,88.0,79.9260637509439,10.284284200858972,0 +FGD-2000,90.0,89.58986737082401,10.863030141894356,0 +FGD-2000,92.0,99.5423571954657,11.435960944123122,0 +FGD-2000,94.0,99.54266877147337,11.43033588057577,0 +FGD-2000,96.0,99.54304922583727,11.424718686872271,0 +FGD-2000,98.0,99.54304922583727,11.424718686872271,0 +FGD-2000,100.0,99.54339145558271,11.413436164797032,0 +FGD-2000,102.0,99.54428929914752,11.407878158423374,0 +FGD-2000,104.0,99.5453928281729,11.399513103006592,0 +FGD-2000,106.0,99.5453928281729,11.399513103006592,0 +FGD-2000,108.0,99.54565862159917,11.381852824589394,0 diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure9.png b/standalone_fgd_replication/result/dist-shift-trace-90/figure9.png new file mode 100644 index 0000000..9442a81 Binary files /dev/null and b/standalone_fgd_replication/result/dist-shift-trace-90/figure9.png differ diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure9a_unalloc.csv b/standalone_fgd_replication/result/dist-shift-trace-90/figure9a_unalloc.csv new file mode 100644 index 0000000..62a2033 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-trace-90/figure9a_unalloc.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.98542740358982,0 +Random,4.0,95.99626799360225,0 +Random,6.0,93.9854274035898,0 +Random,8.0,91.98382797227647,0 +Random,10.0,89.99431313310818,0 +Random,12.0,87.99111427048157,0 +Random,14.0,85.99751199573478,0 +Random,16.0,83.99324684556598,0 +Random,18.0,81.99289141638525,0 +Random,20.0,79.99982228540965,0 +Random,22.0,77.99377998933717,0 +Random,24.0,75.98969255375874,0 +Random,26.0,73.98293939932475,0 +Random,28.0,71.99733428114457,0 +Random,30.0,69.9889816953973,0 +Random,32.0,67.98258397014406,0 +Random,34.0,65.9900479829395,0 +Random,36.0,63.99857828327716,0 +Random,38.0,61.99822285409642,0 +Random,40.0,59.985782832770674,0 +Random,42.0,57.93673360582917,0 +Random,44.0,55.997689710325346,0 +Random,46.0,53.996445708192795,0 +Random,48.0,51.98258397014409,0 +Random,50.0,49.99733428114461,0 +Random,52.0,47.988093122445505,0 +Random,54.0,45.99520170606021,0 +Random,56.0,43.9944908476987,0 +Random,58.0,41.968899946685745,0 +Random,60.0,40.134707659499,0 +Random,62.0,38.22303181091179,0 +Random,64.0,36.41140927670175,0 +Random,66.0,34.56335525146626,0 +Random,68.0,32.70837035720645,0 +Random,70.0,30.84681002310302,0 +Random,72.0,28.835614003909843,0 +Random,74.0,26.9900479829395,0 +Random,76.0,25.130264794739738,0 +Random,78.0,23.135418517860405,0 +Random,80.0,21.128309934245674,0 +Random,82.0,19.131331082281918,0 +Random,84.0,17.265683312599993,0 +Random,86.0,16.003909720988126,0 +Random,88.0,15.230851252887891,0 +Random,90.0,14.422072152123725,0 +Random,92.0,13.568508974586841,0 +Random,94.0,13.361116047627537,0 +Random,96.0,13.275457615070223,0 +Random,98.0,13.250399857828357,0 +Random,100.0,13.239026124044814,0 +Random,102.0,13.212902079260733,0 +Random,104.0,13.178247734139003,0 +Random,106.0,13.051004087435611,0 +Random,108.0,12.90883241514131,0 +Clustering,2.0,97.98542740358982,0 +Clustering,4.0,95.99626799360227,0 +Clustering,6.0,93.98542740358984,0 +Clustering,8.0,91.98382797227644,0 +Clustering,10.0,89.9943131331081,0 +Clustering,12.0,87.99111427048149,0 +Clustering,14.0,85.99751199573473,0 +Clustering,16.0,83.99324684556589,0 +Clustering,18.0,81.99289141638518,0 +Clustering,20.0,79.99982228540954,0 +Clustering,22.0,77.99377998933724,0 +Clustering,24.0,75.98969255375873,0 +Clustering,26.0,73.98293939932475,0 +Clustering,28.0,71.99733428114455,0 +Clustering,30.0,69.98898169539724,0 +Clustering,32.0,67.98258397014399,0 +Clustering,34.0,65.99004798293949,0 +Clustering,36.0,63.99857828327714,0 +Clustering,38.0,61.9982228540964,0 +Clustering,40.0,59.98578283277065,0 +Clustering,42.0,57.93673360582912,0 +Clustering,44.0,55.9976897103253,0 +Clustering,46.0,53.99644570819272,0 +Clustering,48.0,51.98258397014403,0 +Clustering,50.0,49.99733428114456,0 +Clustering,52.0,47.98809312244543,0 +Clustering,54.0,45.99520170606014,0 +Clustering,56.0,43.99449084769868,0 +Clustering,58.0,41.96889994668572,0 +Clustering,60.0,39.992535987204505,0 +Clustering,62.0,37.93868846632304,0 +Clustering,64.0,35.98489425981868,0 +Clustering,66.0,33.994668562288915,0 +Clustering,68.0,31.997511995734797,0 +Clustering,70.0,29.99377998933707,0 +Clustering,72.0,27.98258397014389,0 +Clustering,74.0,25.99484627687927,0 +Clustering,76.0,23.992891416385223,0 +Clustering,78.0,21.998045139505937,0 +Clustering,80.0,19.99093655589122,0 +Clustering,82.0,17.993957703927475,0 +Clustering,84.0,15.986138261951286,0 +Clustering,86.0,13.995734849831146,0 +Clustering,88.0,11.996445708192606,0 +Clustering,90.0,9.996978851963709,0 +Clustering,92.0,7.99768971032518,0 +Clustering,94.0,7.690421183579133,0 +Clustering,96.0,7.649724542384891,0 +Clustering,98.0,7.649724542384891,0 +Clustering,100.0,7.638350808601348,0 +Clustering,102.0,7.632663941709576,0 +Clustering,104.0,7.624133641371919,0 +Clustering,106.0,7.624133641371919,0 +Clustering,108.0,7.606362182335132,0 +FGD-Full,2.0,97.98542740358982,0 +FGD-Full,4.0,95.99626799360227,0 +FGD-Full,6.0,93.98542740358982,0 +FGD-Full,8.0,91.98382797227653,0 +FGD-Full,10.0,89.99431313310822,0 +FGD-Full,12.0,87.9911142704816,0 +FGD-Full,14.0,85.99751199573484,0 +FGD-Full,16.0,83.99324684556603,0 +FGD-Full,18.0,81.99289141638528,0 +FGD-Full,20.0,79.99982228540964,0 +FGD-Full,22.0,77.99377998933711,0 +FGD-Full,24.0,75.98969255375866,0 +FGD-Full,26.0,73.98293939932468,0 +FGD-Full,28.0,71.99733428114448,0 +FGD-Full,30.0,69.98898169539719,0 +FGD-Full,32.0,67.98258397014393,0 +FGD-Full,34.0,65.99004798293939,0 +FGD-Full,36.0,63.998578283277055,0 +FGD-Full,38.0,61.99822285409632,0 +FGD-Full,40.0,59.98578283277056,0 +FGD-Full,42.0,57.93673360582905,0 +FGD-Full,44.0,55.99768971032522,0 +FGD-Full,46.0,53.99644570819264,0 +FGD-Full,48.0,51.98258397014395,0 +FGD-Full,50.0,49.99733428114449,0 +FGD-Full,52.0,47.988093122445356,0 +FGD-Full,54.0,45.99520170606008,0 +FGD-Full,56.0,43.99449084769861,0 +FGD-Full,58.0,41.96889994668564,0 +FGD-Full,60.0,39.99253598720457,0 +FGD-Full,62.0,37.93868846632311,0 +FGD-Full,64.0,35.98489425981875,0 +FGD-Full,66.0,33.99466856228898,0 +FGD-Full,68.0,31.997511995734868,0 +FGD-Full,70.0,29.99377998933714,0 +FGD-Full,72.0,27.98258397014397,0 +FGD-Full,74.0,25.994846276879347,0 +FGD-Full,76.0,23.99289141638531,0 +FGD-Full,78.0,21.998045139505976,0 +FGD-Full,80.0,19.990936555891263,0 +FGD-Full,82.0,17.993957703927503,0 +FGD-Full,84.0,16.128309934245614,0 +FGD-Full,86.0,14.582192998045143,0 +FGD-Full,88.0,13.187133463657371,0 +FGD-Full,90.0,12.609738759552164,0 +FGD-Full,92.0,12.539719210947222,0 +FGD-Full,94.0,12.53403234405545,0 +FGD-Full,96.0,12.528345477163679,0 +FGD-Full,98.0,12.528345477163679,0 +FGD-Full,100.0,12.516971743380138,0 +FGD-Full,102.0,12.511284876488366,0 +FGD-Full,104.0,12.502754576150704,0 +FGD-Full,106.0,12.502754576150704,0 +FGD-Full,108.0,12.484983117113918,0 +FGD-2000,2.0,97.98542740358982,0 +FGD-2000,4.0,95.99626799360227,0 +FGD-2000,6.0,93.98542740358982,0 +FGD-2000,8.0,91.98382797227653,0 +FGD-2000,10.0,89.99431313310822,0 +FGD-2000,12.0,87.9911142704816,0 +FGD-2000,14.0,85.99751199573484,0 +FGD-2000,16.0,83.993246845566,0 +FGD-2000,18.0,81.99289141638528,0 +FGD-2000,20.0,79.99982228540964,0 +FGD-2000,22.0,77.99377998933711,0 +FGD-2000,24.0,75.98969255375866,0 +FGD-2000,26.0,73.98293939932468,0 +FGD-2000,28.0,71.99733428114448,0 +FGD-2000,30.0,69.98898169539719,0 +FGD-2000,32.0,67.98258397014393,0 +FGD-2000,34.0,65.99004798293939,0 +FGD-2000,36.0,63.998578283277055,0 +FGD-2000,38.0,61.998222854096305,0 +FGD-2000,40.0,59.98578283277056,0 +FGD-2000,42.0,57.936733605829026,0 +FGD-2000,44.0,55.99768971032522,0 +FGD-2000,46.0,53.99644570819264,0 +FGD-2000,48.0,51.98258397014395,0 +FGD-2000,50.0,49.99733428114449,0 +FGD-2000,52.0,47.988093122445356,0 +FGD-2000,54.0,45.99520170606008,0 +FGD-2000,56.0,43.994490847698614,0 +FGD-2000,58.0,41.96889994668563,0 +FGD-2000,60.0,39.99253598720456,0 +FGD-2000,62.0,37.9386884663231,0 +FGD-2000,64.0,35.98489425981876,0 +FGD-2000,66.0,33.994668562288986,0 +FGD-2000,68.0,31.99751199573487,0 +FGD-2000,70.0,29.99377998933715,0 +FGD-2000,72.0,27.98258397014398,0 +FGD-2000,74.0,25.994846276879365,0 +FGD-2000,76.0,23.992891416385323,0 +FGD-2000,78.0,21.998045139505994,0 +FGD-2000,80.0,19.99093655589127,0 +FGD-2000,82.0,17.99395770392751,0 +FGD-2000,84.0,16.12830993424562,0 +FGD-2000,86.0,14.440021325750852,0 +FGD-2000,88.0,12.867247200995205,0 +FGD-2000,90.0,12.125288786209353,0 +FGD-2000,92.0,11.488537408921284,0 +FGD-2000,94.0,11.48285054202951,0 +FGD-2000,96.0,11.477163675137737,0 +FGD-2000,98.0,11.477163675137737,0 +FGD-2000,100.0,11.465789941354194,0 +FGD-2000,102.0,11.460103074462424,0 +FGD-2000,104.0,11.451572774124763,0 +FGD-2000,106.0,11.451572774124763,0 +FGD-2000,108.0,11.433801315087976,0 diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure9b_occupied.csv b/standalone_fgd_replication/result/dist-shift-trace-90/figure9b_occupied.csv new file mode 100644 index 0000000..3cdaabd --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-trace-90/figure9b_occupied.csv @@ -0,0 +1,217 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,122,0 +Random,4.0,247,0 +Random,6.0,355,0 +Random,8.0,450,0 +Random,10.0,545,0 +Random,12.0,631,0 +Random,14.0,702,0 +Random,16.0,763,0 +Random,18.0,822,0 +Random,20.0,862,0 +Random,22.0,908,0 +Random,24.0,937,0 +Random,26.0,969,0 +Random,28.0,996,0 +Random,30.0,1017,0 +Random,32.0,1026,0 +Random,34.0,1039,0 +Random,36.0,1053,0 +Random,38.0,1057,0 +Random,40.0,1061,0 +Random,42.0,1067,0 +Random,44.0,1076,0 +Random,46.0,1083,0 +Random,48.0,1084,0 +Random,50.0,1089,0 +Random,52.0,1091,0 +Random,54.0,1094,0 +Random,56.0,1095,0 +Random,58.0,1095,0 +Random,60.0,1098,0 +Random,62.0,1098,0 +Random,64.0,1099,0 +Random,66.0,1099,0 +Random,68.0,1099,0 +Random,70.0,1100,0 +Random,72.0,1100,0 +Random,74.0,1100,0 +Random,76.0,1100,0 +Random,78.0,1100,0 +Random,80.0,1100,0 +Random,82.0,1100,0 +Random,84.0,1100,0 +Random,86.0,1100,0 +Random,88.0,1100,0 +Random,90.0,1100,0 +Random,92.0,1100,0 +Random,94.0,1100,0 +Random,96.0,1100,0 +Random,98.0,1100,0 +Random,100.0,1100,0 +Random,102.0,1100,0 +Random,104.0,1100,0 +Random,106.0,1100,0 +Random,108.0,1100,0 +Clustering,2.0,79,0 +Clustering,4.0,142,0 +Clustering,6.0,193,0 +Clustering,8.0,252,0 +Clustering,10.0,310,0 +Clustering,12.0,367,0 +Clustering,14.0,426,0 +Clustering,16.0,485,0 +Clustering,18.0,524,0 +Clustering,20.0,550,0 +Clustering,22.0,566,0 +Clustering,24.0,581,0 +Clustering,26.0,596,0 +Clustering,28.0,610,0 +Clustering,30.0,624,0 +Clustering,32.0,639,0 +Clustering,34.0,654,0 +Clustering,36.0,668,0 +Clustering,38.0,684,0 +Clustering,40.0,700,0 +Clustering,42.0,715,0 +Clustering,44.0,730,0 +Clustering,46.0,745,0 +Clustering,48.0,761,0 +Clustering,50.0,776,0 +Clustering,52.0,790,0 +Clustering,54.0,806,0 +Clustering,56.0,821,0 +Clustering,58.0,836,0 +Clustering,60.0,851,0 +Clustering,62.0,866,0 +Clustering,64.0,880,0 +Clustering,66.0,895,0 +Clustering,68.0,911,0 +Clustering,70.0,926,0 +Clustering,72.0,941,0 +Clustering,74.0,957,0 +Clustering,76.0,972,0 +Clustering,78.0,987,0 +Clustering,80.0,1005,0 +Clustering,82.0,1021,0 +Clustering,84.0,1037,0 +Clustering,86.0,1053,0 +Clustering,88.0,1068,0 +Clustering,90.0,1083,0 +Clustering,92.0,1098,0 +Clustering,94.0,1100,0 +Clustering,96.0,1100,0 +Clustering,98.0,1100,0 +Clustering,100.0,1100,0 +Clustering,102.0,1100,0 +Clustering,104.0,1100,0 +Clustering,106.0,1100,0 +Clustering,108.0,1100,0 +FGD-Full,2.0,75,0 +FGD-Full,4.0,136,0 +FGD-Full,6.0,180,0 +FGD-Full,8.0,207,0 +FGD-Full,10.0,219,0 +FGD-Full,12.0,233,0 +FGD-Full,14.0,248,0 +FGD-Full,16.0,263,0 +FGD-Full,18.0,279,0 +FGD-Full,20.0,296,0 +FGD-Full,22.0,311,0 +FGD-Full,24.0,327,0 +FGD-Full,26.0,345,0 +FGD-Full,28.0,366,0 +FGD-Full,30.0,387,0 +FGD-Full,32.0,404,0 +FGD-Full,34.0,424,0 +FGD-Full,36.0,447,0 +FGD-Full,38.0,471,0 +FGD-Full,40.0,499,0 +FGD-Full,42.0,510,0 +FGD-Full,44.0,524,0 +FGD-Full,46.0,539,0 +FGD-Full,48.0,559,0 +FGD-Full,50.0,578,0 +FGD-Full,52.0,597,0 +FGD-Full,54.0,613,0 +FGD-Full,56.0,629,0 +FGD-Full,58.0,654,0 +FGD-Full,60.0,675,0 +FGD-Full,62.0,694,0 +FGD-Full,64.0,709,0 +FGD-Full,66.0,743,0 +FGD-Full,68.0,795,0 +FGD-Full,70.0,848,0 +FGD-Full,72.0,906,0 +FGD-Full,74.0,960,0 +FGD-Full,76.0,1015,0 +FGD-Full,78.0,1069,0 +FGD-Full,80.0,1083,0 +FGD-Full,82.0,1097,0 +FGD-Full,84.0,1100,0 +FGD-Full,86.0,1100,0 +FGD-Full,88.0,1100,0 +FGD-Full,90.0,1100,0 +FGD-Full,92.0,1100,0 +FGD-Full,94.0,1100,0 +FGD-Full,96.0,1100,0 +FGD-Full,98.0,1100,0 +FGD-Full,100.0,1100,0 +FGD-Full,102.0,1100,0 +FGD-Full,104.0,1100,0 +FGD-Full,106.0,1100,0 +FGD-Full,108.0,1100,0 +FGD-2000,2.0,74,0 +FGD-2000,4.0,135,0 +FGD-2000,6.0,178,0 +FGD-2000,8.0,208,0 +FGD-2000,10.0,219,0 +FGD-2000,12.0,233,0 +FGD-2000,14.0,248,0 +FGD-2000,16.0,263,0 +FGD-2000,18.0,278,0 +FGD-2000,20.0,295,0 +FGD-2000,22.0,310,0 +FGD-2000,24.0,325,0 +FGD-2000,26.0,340,0 +FGD-2000,28.0,362,0 +FGD-2000,30.0,382,0 +FGD-2000,32.0,399,0 +FGD-2000,34.0,419,0 +FGD-2000,36.0,442,0 +FGD-2000,38.0,466,0 +FGD-2000,40.0,493,0 +FGD-2000,42.0,504,0 +FGD-2000,44.0,517,0 +FGD-2000,46.0,533,0 +FGD-2000,48.0,550,0 +FGD-2000,50.0,566,0 +FGD-2000,52.0,586,0 +FGD-2000,54.0,600,0 +FGD-2000,56.0,616,0 +FGD-2000,58.0,640,0 +FGD-2000,60.0,660,0 +FGD-2000,62.0,677,0 +FGD-2000,64.0,692,0 +FGD-2000,66.0,712,0 +FGD-2000,68.0,757,0 +FGD-2000,70.0,810,0 +FGD-2000,72.0,868,0 +FGD-2000,74.0,922,0 +FGD-2000,76.0,979,0 +FGD-2000,78.0,1035,0 +FGD-2000,80.0,1073,0 +FGD-2000,82.0,1087,0 +FGD-2000,84.0,1100,0 +FGD-2000,86.0,1100,0 +FGD-2000,88.0,1100,0 +FGD-2000,90.0,1100,0 +FGD-2000,92.0,1100,0 +FGD-2000,94.0,1100,0 +FGD-2000,96.0,1100,0 +FGD-2000,98.0,1100,0 +FGD-2000,100.0,1100,0 +FGD-2000,102.0,1100,0 +FGD-2000,104.0,1100,0 +FGD-2000,106.0,1100,0 +FGD-2000,108.0,1100,0 diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure9c_failed.csv b/standalone_fgd_replication/result/dist-shift-trace-90/figure9c_failed.csv new file mode 100644 index 0000000..c160082 --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-trace-90/figure9c_failed.csv @@ -0,0 +1,17 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,8,132.0,0 +Random,1,283.0,0 +Random,2,10.0,0 +Random,<1,97.02000000000011,0 +Clustering,<1,100.46000000000014,0 +Clustering,1,69.0,0 +Clustering,2,4.0,0 +Clustering,8,32.0,0 +FGD-Full,8,68.0,0 +FGD-Full,1,239.0,0 +FGD-Full,2,10.0,0 +FGD-Full,<1,162.98000000000025,0 +FGD-2000,8,68.0,0 +FGD-2000,1,211.0,0 +FGD-2000,2,10.0,0 +FGD-2000,<1,131.83000000000013,0 diff --git a/standalone_fgd_replication/result/dist-shift-trace-90/figure9d_breakdown.csv b/standalone_fgd_replication/result/dist-shift-trace-90/figure9d_breakdown.csv new file mode 100644 index 0000000..c3e4b9e --- /dev/null +++ b/standalone_fgd_replication/result/dist-shift-trace-90/figure9d_breakdown.csv @@ -0,0 +1,13 @@ +scheduler,cause,pct,run +Random,deficient,31.742174487365176,0 +Random,stranded,54.80276646463693,0 +Random,non_gpu,13.4550590479979,0 +Clustering,deficient,49.40122363908484,0 +Clustering,stranded,37.16395690272077,0 +Clustering,non_gpu,13.434819458194402,0 +FGD-Full,deficient,22.65009631998931,0 +FGD-Full,stranded,63.92528196978186,0 +FGD-Full,non_gpu,13.424621710228829,0 +FGD-2000,deficient,26.0131784874932,0 +FGD-2000,stranded,60.57948839348867,0 +FGD-2000,non_gpu,13.407333119018135,0 diff --git a/standalone_fgd_replication/result/fig11-runs10-seed42/experiment_summary.log b/standalone_fgd_replication/result/fig11-runs10-seed42/experiment_summary.log new file mode 100644 index 0000000..8c1660f --- /dev/null +++ b/standalone_fgd_replication/result/fig11-runs10-seed42/experiment_summary.log @@ -0,0 +1,20 @@ +Experiment: Sensitivity Analysis (Figures 11-14) +Result: fig11-runs10-seed42 +Figures: [11] +Runs: 10 +Seed: 42 +Nodes: 1213 +GPUs: 6212 + +Figure 11 (6.3): GPU-Sharing Task Proportion +====================================================================== +Scheduler 40% 60% 80% 100% +-------------------------------------------- +Random 14.2% 16.5% 19.1% 21.1% +BestFit 8.4% 11.0% 13.3% 15.5% +BestFit-PN 7.8% 10.4% 12.7% 15.0% +DotProd 11.4% 14.3% 16.6% 18.9% +Packing 7.1% 9.7% 11.9% 14.3% +Clustering 7.1% 9.7% 12.0% 14.3% +FGD 6.2% 9.1% 11.3% 13.7% + diff --git a/standalone_fgd_replication/result/fig11-runs10-seed42/figure11.png b/standalone_fgd_replication/result/fig11-runs10-seed42/figure11.png new file mode 100644 index 0000000..6847146 Binary files /dev/null and b/standalone_fgd_replication/result/fig11-runs10-seed42/figure11.png differ diff --git a/standalone_fgd_replication/result/fig11-runs10-seed42/figure11_results.csv b/standalone_fgd_replication/result/fig11-runs10-seed42/figure11_results.csv new file mode 100644 index 0000000..e5fd256 --- /dev/null +++ b/standalone_fgd_replication/result/fig11-runs10-seed42/figure11_results.csv @@ -0,0 +1,29 @@ +proportion,scheduler,unalloc_gpu_pct,std +40,Random,14.18,0.30 +40,BestFit,8.36,0.19 +40,BestFit-PN,7.75,0.14 +40,DotProd,11.39,0.36 +40,Packing,7.07,0.12 +40,Clustering,7.09,0.10 +40,FGD,6.22,0.12 +60,Random,16.54,0.44 +60,BestFit,11.01,0.26 +60,BestFit-PN,10.35,0.17 +60,DotProd,14.26,0.36 +60,Packing,9.71,0.12 +60,Clustering,9.71,0.12 +60,FGD,9.08,0.24 +80,Random,19.07,0.33 +80,BestFit,13.28,0.20 +80,BestFit-PN,12.66,0.13 +80,DotProd,16.62,0.28 +80,Packing,11.93,0.12 +80,Clustering,11.96,0.14 +80,FGD,11.28,0.18 +100,Random,21.05,0.51 +100,BestFit,15.50,0.17 +100,BestFit-PN,14.96,0.22 +100,DotProd,18.92,0.30 +100,Packing,14.31,0.16 +100,Clustering,14.33,0.16 +100,FGD,13.70,0.19 diff --git a/standalone_fgd_replication/result/fig11-runs10-seed42/paper-figure11.png b/standalone_fgd_replication/result/fig11-runs10-seed42/paper-figure11.png new file mode 100644 index 0000000..4217f65 Binary files /dev/null and b/standalone_fgd_replication/result/fig11-runs10-seed42/paper-figure11.png differ diff --git a/standalone_fgd_replication/result/fig12-runs10-seed42/experiment_summary.log b/standalone_fgd_replication/result/fig12-runs10-seed42/experiment_summary.log new file mode 100644 index 0000000..48dc24b --- /dev/null +++ b/standalone_fgd_replication/result/fig12-runs10-seed42/experiment_summary.log @@ -0,0 +1,20 @@ +Experiment: Sensitivity Analysis (Figures 11-14) +Result: fig12-runs10-seed42 +Figures: [12] +Runs: 10 +Seed: 42 +Nodes: 1213 +GPUs: 6212 + +Figure 12 (6.4): Multi-GPU Task Proportion +====================================================================== +Scheduler 20% 30% 40% 50% +-------------------------------------------- +Random 12.3% 12.1% 15.1% 19.8% +BestFit 6.0% 5.2% 4.6% 3.9% +BestFit-PN 5.5% 4.8% 4.3% 3.7% +DotProd 8.8% 7.4% 6.4% 5.4% +Packing 5.0% 4.5% 4.0% 3.5% +Clustering 5.1% 4.5% 4.0% 3.5% +FGD 4.4% 3.8% 3.2% 2.7% + diff --git a/standalone_fgd_replication/result/fig12-runs10-seed42/figure12.png b/standalone_fgd_replication/result/fig12-runs10-seed42/figure12.png new file mode 100644 index 0000000..49acb43 Binary files /dev/null and b/standalone_fgd_replication/result/fig12-runs10-seed42/figure12.png differ diff --git a/standalone_fgd_replication/result/fig12-runs10-seed42/figure12_results.csv b/standalone_fgd_replication/result/fig12-runs10-seed42/figure12_results.csv new file mode 100644 index 0000000..818c112 --- /dev/null +++ b/standalone_fgd_replication/result/fig12-runs10-seed42/figure12_results.csv @@ -0,0 +1,29 @@ +proportion,scheduler,unalloc_gpu_pct,std +20,Random,12.28,0.40 +20,BestFit,6.04,0.20 +20,BestFit-PN,5.45,0.15 +20,DotProd,8.82,0.45 +20,Packing,5.04,0.16 +20,Clustering,5.09,0.18 +20,FGD,4.44,0.16 +30,Random,12.08,0.64 +30,BestFit,5.24,0.19 +30,BestFit-PN,4.83,0.21 +30,DotProd,7.40,0.29 +30,Packing,4.50,0.16 +30,Clustering,4.50,0.11 +30,FGD,3.78,0.15 +40,Random,15.14,1.30 +40,BestFit,4.59,0.10 +40,BestFit-PN,4.27,0.15 +40,DotProd,6.40,0.25 +40,Packing,3.99,0.14 +40,Clustering,4.03,0.21 +40,FGD,3.21,0.18 +50,Random,19.77,1.17 +50,BestFit,3.94,0.12 +50,BestFit-PN,3.67,0.18 +50,DotProd,5.37,0.23 +50,Packing,3.50,0.19 +50,Clustering,3.51,0.15 +50,FGD,2.74,0.12 diff --git a/standalone_fgd_replication/result/fig12-runs10-seed42/paper-figure12.png b/standalone_fgd_replication/result/fig12-runs10-seed42/paper-figure12.png new file mode 100644 index 0000000..baa00a2 Binary files /dev/null and b/standalone_fgd_replication/result/fig12-runs10-seed42/paper-figure12.png differ diff --git a/standalone_fgd_replication/result/fig13-runs10-seed42/experiment_summary.log b/standalone_fgd_replication/result/fig13-runs10-seed42/experiment_summary.log new file mode 100644 index 0000000..86c59f0 --- /dev/null +++ b/standalone_fgd_replication/result/fig13-runs10-seed42/experiment_summary.log @@ -0,0 +1,20 @@ +Experiment: Sensitivity Analysis (Figures 11-14) +Result: fig13-runs10-seed42 +Figures: [13] +Runs: 10 +Seed: 42 +Nodes: 1213 +GPUs: 6212 + +Figure 13 (6.5): GPU-Type Constrained Task Proportion +====================================================================== +Scheduler 10% 20% 25% 33% +-------------------------------------------- +Random 12.8% 13.3% 13.6% 15.6% +BestFit 6.8% 11.8% 14.5% 19.4% +BestFit-PN 6.2% 6.3% 8.1% 13.8% +DotProd 10.8% 12.2% 15.2% 20.6% +Packing 5.6% 11.0% 13.7% 18.0% +Clustering 5.7% 11.1% 13.9% 18.3% +FGD 5.5% 5.9% 6.4% 12.2% + diff --git a/standalone_fgd_replication/result/fig13-runs10-seed42/figure13.png b/standalone_fgd_replication/result/fig13-runs10-seed42/figure13.png new file mode 100644 index 0000000..6ccdc17 Binary files /dev/null and b/standalone_fgd_replication/result/fig13-runs10-seed42/figure13.png differ diff --git a/standalone_fgd_replication/result/fig13-runs10-seed42/figure13_results.csv b/standalone_fgd_replication/result/fig13-runs10-seed42/figure13_results.csv new file mode 100644 index 0000000..2978bd6 --- /dev/null +++ b/standalone_fgd_replication/result/fig13-runs10-seed42/figure13_results.csv @@ -0,0 +1,29 @@ +proportion,scheduler,unalloc_gpu_pct,std +10,Random,12.81,0.20 +10,BestFit,6.76,0.13 +10,BestFit-PN,6.16,0.18 +10,DotProd,10.76,0.21 +10,Packing,5.63,0.12 +10,Clustering,5.70,0.15 +10,FGD,5.50,0.24 +20,Random,13.26,0.38 +20,BestFit,11.80,0.46 +20,BestFit-PN,6.31,0.17 +20,DotProd,12.24,0.43 +20,Packing,11.03,0.42 +20,Clustering,11.09,0.42 +20,FGD,5.85,0.29 +25,Random,13.57,0.29 +25,BestFit,14.49,0.31 +25,BestFit-PN,8.14,0.40 +25,DotProd,15.19,0.27 +25,Packing,13.69,0.42 +25,Clustering,13.86,0.38 +25,FGD,6.43,0.36 +33,Random,15.63,0.55 +33,BestFit,19.40,0.40 +33,BestFit-PN,13.82,0.49 +33,DotProd,20.56,0.48 +33,Packing,17.98,0.43 +33,Clustering,18.33,0.48 +33,FGD,12.23,0.50 diff --git a/standalone_fgd_replication/result/fig13-runs10-seed42/paper-figure13.png b/standalone_fgd_replication/result/fig13-runs10-seed42/paper-figure13.png new file mode 100644 index 0000000..c32aa27 Binary files /dev/null and b/standalone_fgd_replication/result/fig13-runs10-seed42/paper-figure13.png differ diff --git a/standalone_fgd_replication/result/fig14-runs10-seed42/experiment_summary.log b/standalone_fgd_replication/result/fig14-runs10-seed42/experiment_summary.log new file mode 100644 index 0000000..236fcae --- /dev/null +++ b/standalone_fgd_replication/result/fig14-runs10-seed42/experiment_summary.log @@ -0,0 +1,20 @@ +Experiment: Sensitivity Analysis (Figures 11-14) +Result: fig14-runs10-seed42 +Figures: [14] +Runs: 10 +Seed: 42 +Nodes: 1213 +GPUs: 6212 + +Figure 14 (6.6): Non-GPU Task Proportion +====================================================================== +Scheduler 5% 10% 20% 25% +-------------------------------------------- +Random 9.5% 11.2% 16.7% 19.8% +BestFit 6.3% 6.5% 7.9% 8.7% +BestFit-PN 5.9% 5.9% 7.4% 9.8% +DotProd 7.2% 9.0% 13.3% 16.4% +Packing 5.8% 5.6% 7.9% 11.8% +Clustering 5.7% 5.7% 5.7% 6.5% +FGD 4.9% 4.9% 5.9% 8.0% + diff --git a/standalone_fgd_replication/result/fig14-runs10-seed42/figure14.png b/standalone_fgd_replication/result/fig14-runs10-seed42/figure14.png new file mode 100644 index 0000000..81a580a Binary files /dev/null and b/standalone_fgd_replication/result/fig14-runs10-seed42/figure14.png differ diff --git a/standalone_fgd_replication/result/fig14-runs10-seed42/figure14_results.csv b/standalone_fgd_replication/result/fig14-runs10-seed42/figure14_results.csv new file mode 100644 index 0000000..2f12ce6 --- /dev/null +++ b/standalone_fgd_replication/result/fig14-runs10-seed42/figure14_results.csv @@ -0,0 +1,29 @@ +proportion,scheduler,unalloc_gpu_pct,std +5,Random,9.54,0.27 +5,BestFit,6.33,0.19 +5,BestFit-PN,5.88,0.21 +5,DotProd,7.18,0.12 +5,Packing,5.76,0.18 +5,Clustering,5.73,0.17 +5,FGD,4.91,0.18 +10,Random,11.18,0.50 +10,BestFit,6.52,0.21 +10,BestFit-PN,5.93,0.14 +10,DotProd,8.95,0.30 +10,Packing,5.60,0.18 +10,Clustering,5.69,0.20 +10,FGD,4.90,0.14 +20,Random,16.68,0.59 +20,BestFit,7.88,0.25 +20,BestFit-PN,7.39,0.35 +20,DotProd,13.33,0.42 +20,Packing,7.88,0.58 +20,Clustering,5.71,0.13 +20,FGD,5.91,0.23 +25,Random,19.83,0.46 +25,BestFit,8.73,0.22 +25,BestFit-PN,9.85,0.69 +25,DotProd,16.35,0.42 +25,Packing,11.80,0.45 +25,Clustering,6.48,0.52 +25,FGD,7.97,0.55 diff --git a/standalone_fgd_replication/result/fig14-runs10-seed42/paper-figure14.png b/standalone_fgd_replication/result/fig14-runs10-seed42/paper-figure14.png new file mode 100644 index 0000000..67b1d01 Binary files /dev/null and b/standalone_fgd_replication/result/fig14-runs10-seed42/paper-figure14.png differ diff --git a/standalone_fgd_replication/result/fig7-runs10-seed42/experiment_summary.log b/standalone_fgd_replication/result/fig7-runs10-seed42/experiment_summary.log new file mode 100644 index 0000000..b8ebc8f --- /dev/null +++ b/standalone_fgd_replication/result/fig7-runs10-seed42/experiment_summary.log @@ -0,0 +1,18 @@ +Experiment: Figure 7(a) Replication +Seed: 42 +Num runs: 10 +Max workload: 120.0% +Sample interval: 5.0% + +============================================================ +EXPERIMENT SUMMARY +============================================================ + +Scheduler Avg Frag% Frag/Total% Avg Alloc% Scheduled Failed +------------------------------------------------------------ +Random 99.5 12.0 88.0 7984 2018 +BestFit 99.7 6.8 93.2 8089 1901 +DotProd 99.6 10.1 89.9 7854 2137 +Packing 99.6 5.5 94.5 8185 1805 +Clustering 99.3 5.5 94.5 8184 1806 +FGD 99.3 4.8 95.2 8241 1750 diff --git a/standalone_fgd_replication/result/fig7-runs10-seed42/figure7.png b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7.png new file mode 100644 index 0000000..4a91146 Binary files /dev/null and b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7.png differ diff --git a/standalone_fgd_replication/result/fig7-runs10-seed42/figure7_results.csv b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7_results.csv new file mode 100644 index 0000000..989e58c --- /dev/null +++ b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7_results.csv @@ -0,0 +1,1441 @@ +scheduler,arrived_workload_pct,frag_rate,frag_total_pct,run +Random,5.0,15.010463108326377,14.258369315269936,0 +Random,10.0,16.005944662739978,14.404525679033256,0 +Random,15.0,17.020418301629743,14.466971966790599,0 +Random,20.0,18.256997476387735,14.6044223856513,0 +Random,25.0,19.229667836451046,14.422096098942951,0 +Random,30.0,20.580259877190688,14.40485672022299,0 +Random,35.0,21.84738124354117,14.200586790453338,0 +Random,40.0,23.39637284192798,14.037145767759595,0 +Random,45.0,25.461364943218324,14.00125048814947,0 +Random,50.0,27.916570115288998,13.955858311369212,0 +Random,55.0,31.253731642981545,14.061110215468203,0 +Random,60.0,35.3624507511789,14.142930963338532,0 +Random,65.0,40.31238663226873,14.25898175331923,0 +Random,70.0,46.249718495874774,14.345900286696953,0 +Random,75.0,55.43956872111732,14.565470464743552,0 +Random,80.0,67.60323848974917,14.472447317768527,0 +Random,85.0,86.91760398761753,14.590880008745582,0 +Random,90.0,98.10295845351334,13.6169180452282,0 +Random,95.0,98.89540296781479,13.120834556340002,0 +Random,100.0,99.11447837240512,12.874032567470445,0 +Random,105.0,99.26313707334927,12.694879568463172,0 +Random,110.0,99.41607745036411,12.486864177378013,0 +Random,115.0,99.47158595529315,12.354844954872197,0 +Random,120.0,99.48446010203496,12.286298792833108,0 +Random,5.0,15.014452690858048,14.262763253179864,1 +Random,10.0,16.04279342680198,14.437765144956641,1 +Random,15.0,17.089489258007266,14.52515802457739,1 +Random,20.0,18.018537417489853,14.414104783580676,1 +Random,25.0,19.213192304289915,14.407327108189671,1 +Random,30.0,20.363100853791817,14.253154409427532,1 +Random,35.0,21.64075955524875,14.065274415057846,1 +Random,40.0,23.279816951078587,13.964629797056165,1 +Random,45.0,25.09769858427736,13.801471711499522,1 +Random,50.0,27.582351887132944,13.824477237699394,1 +Random,55.0,30.765552751540977,13.880603194014283,1 +Random,60.0,35.00135952446527,14.041393754498388,1 +Random,65.0,40.47657700649996,14.268840457735724,1 +Random,70.0,45.88268825274763,14.29084721268214,1 +Random,75.0,54.77505132587407,14.468567042673413,1 +Random,80.0,67.25115074030104,14.39772221386696,1 +Random,85.0,85.32478921582884,14.326103533823192,1 +Random,90.0,97.71230265106499,13.278460162419467,1 +Random,95.0,98.97237391855928,12.662951234180916,1 +Random,100.0,99.11694074441498,12.44865376187905,1 +Random,105.0,99.23525817830637,12.230921292923144,1 +Random,110.0,99.33713937297318,12.073012473246516,1 +Random,115.0,99.44679739448891,11.893273457874077,1 +Random,120.0,99.4864299070372,11.77021197615551,1 +Random,5.0,15.132591877674006,14.375231476069231,2 +Random,10.0,16.15302370513409,14.536941246547336,2 +Random,15.0,17.171018849545955,14.594951396739395,2 +Random,20.0,18.384634509954203,14.7056063377602,2 +Random,25.0,19.502010716030803,14.623839539098341,2 +Random,30.0,20.81733736363372,14.569823861758538,2 +Random,35.0,22.226580813776987,14.445774765925165,2 +Random,40.0,23.862445180103613,14.31696773300209,2 +Random,45.0,25.700112233109206,14.13439978069604,2 +Random,50.0,28.611433077326797,14.301156764235461,2 +Random,55.0,31.351342981724617,14.10664074076764,2 +Random,60.0,35.30847414336138,14.255995372374318,2 +Random,65.0,39.88578368999787,14.26693679317056,2 +Random,70.0,46.36117781427781,14.26427165882991,2 +Random,75.0,55.04086258947797,14.253740445539847,2 +Random,80.0,65.88699770682453,14.216403130444236,2 +Random,85.0,82.91156275889536,13.926793471529622,2 +Random,90.0,96.66534496344516,13.250092495641358,2 +Random,95.0,98.83461087099506,12.55511399396649,2 +Random,100.0,99.04160058990304,12.333007038041494,2 +Random,105.0,99.23921529075837,12.133959044098967,2 +Random,110.0,99.36364808482486,11.953709189753937,2 +Random,115.0,99.45660497098918,11.784935252261091,2 +Random,120.0,99.47473368593914,11.670026025161306,2 +Random,5.0,14.848422888946825,14.105404174357448,3 +Random,10.0,15.92870518433243,14.333578184804157,3 +Random,15.0,17.041014993595244,14.48351855631594,3 +Random,20.0,17.9979368661,14.396755985913417,3 +Random,25.0,19.162651425101917,14.36967498406005,3 +Random,30.0,20.59836261761853,14.418688037398836,3 +Random,35.0,22.01448097868406,14.290382088357239,3 +Random,40.0,23.556616302477714,14.13252877791375,3 +Random,45.0,25.408961807150664,13.97255661823293,3 +Random,50.0,28.434686792164353,14.251811070187973,3 +Random,55.0,31.547036958574857,14.236387579960125,3 +Random,60.0,35.945326882427516,14.422339107346732,3 +Random,65.0,41.253243127884815,14.597950178893331,3 +Random,70.0,47.808852216452905,14.828594320593819,3 +Random,75.0,56.56098275506641,14.933938680839919,3 +Random,80.0,68.73276862870154,14.800891382312953,3 +Random,85.0,86.5795995782172,14.538041616877464,3 +Random,90.0,98.4041874483254,13.340167156448551,3 +Random,95.0,98.8759150525646,12.979930973449047,3 +Random,100.0,99.010313290847,12.820337346848973,3 +Random,105.0,99.17822356449666,12.558051401984269,3 +Random,110.0,99.28247443267175,12.386975045765942,3 +Random,115.0,99.40684614559277,12.165176836500512,3 +Random,120.0,99.45968330616174,12.027865082113326,3 +Random,5.0,14.955944654965004,14.207906663287984,4 +Random,10.0,15.894408566205682,14.30302312643792,4 +Random,15.0,16.9188376485213,14.379296150032763,4 +Random,20.0,18.0232508361488,14.417846315213717,4 +Random,25.0,19.21455878257182,14.402443895192823,4 +Random,30.0,20.534528683060504,14.373608122270495,4 +Random,35.0,22.012926441344124,14.30740997512169,4 +Random,40.0,23.739676846304008,14.243080006913026,4 +Random,45.0,25.76456740283637,14.16930928267612,4 +Random,50.0,28.718182894035916,14.356779938414146,4 +Random,55.0,32.010428388098155,14.400828025563218,4 +Random,60.0,36.33293057649342,14.529896885922122,4 +Random,65.0,41.5886424955981,14.661402406118858,4 +Random,70.0,47.816739901315685,14.65138163685843,4 +Random,75.0,56.86779441469736,14.729234787744963,4 +Random,80.0,71.13380992017436,14.956994285807212,4 +Random,85.0,92.18155860463287,15.005175214074832,4 +Random,90.0,98.45416208337136,13.831288266023417,4 +Random,95.0,99.05776905306487,13.346806522814697,4 +Random,100.0,99.20803103299303,13.120629422966172,4 +Random,105.0,99.3355935814245,12.926739719792662,4 +Random,110.0,99.40906853319935,12.820121214313701,4 +Random,115.0,99.44147140842264,12.739457787548448,4 +Random,120.0,99.45266142056606,12.660842515230536,4 +Random,5.0,14.882662970468596,14.137691294572392,5 +Random,10.0,16.118048628174552,14.505179953390321,5 +Random,15.0,17.10922613051672,14.541244762266366,5 +Random,20.0,18.17854220427097,14.540902366466538,5 +Random,25.0,19.23471580894519,14.424148064589854,5 +Random,30.0,20.61763053172907,14.429420651851723,5 +Random,35.0,22.056278821604423,14.335196503080194,5 +Random,40.0,23.719794338292896,14.231151110232018,5 +Random,45.0,25.95438792593382,14.272615401543213,5 +Random,50.0,28.64582687393616,14.318302067542167,5 +Random,55.0,31.482655367793893,14.164914298167371,5 +Random,60.0,35.61628091242709,14.292150741671266,5 +Random,65.0,40.93455634023306,14.480500461451317,5 +Random,70.0,47.885322630708096,14.734911954575827,5 +Random,75.0,57.4193122762658,14.866721422875184,5 +Random,80.0,70.35663984886271,14.971512408791837,5 +Random,85.0,86.99415179966643,14.61731419276499,5 +Random,90.0,97.82718813681689,13.590766521885817,5 +Random,95.0,98.85896310585743,13.014149108029194,5 +Random,100.0,99.0549078336131,12.698226868032789,5 +Random,105.0,99.20351115049185,12.504401362837548,5 +Random,110.0,99.28805883469597,12.370409854427157,5 +Random,115.0,99.38893013018271,12.177383871761679,5 +Random,120.0,99.47121565317306,11.999796248926515,5 +Random,5.0,14.844115960985796,14.099974597268695,6 +Random,10.0,15.88787226578377,14.29831775625629,6 +Random,15.0,16.983151519517012,14.435350720407483,6 +Random,20.0,17.99464529388586,14.39449959779003,6 +Random,25.0,19.006676538691302,14.254426066519713,6 +Random,30.0,20.223621573255134,14.155883986611078,6 +Random,35.0,21.99117160554731,14.293942933585749,6 +Random,40.0,23.81281553114292,14.284469298556019,6 +Random,45.0,26.2051621086843,14.411025215844225,6 +Random,50.0,29.003395625946098,14.49978355151034,6 +Random,55.0,32.65949063345587,14.695771863094414,6 +Random,60.0,36.69353041789393,14.817168916946317,6 +Random,65.0,41.49238778080775,14.789244257687315,6 +Random,70.0,48.80612835511947,14.952494384700968,6 +Random,75.0,57.464244789822224,14.886310573981632,6 +Random,80.0,70.97341298114802,14.932865502332671,6 +Random,85.0,90.4410091505073,14.614405181146086,6 +Random,90.0,98.33123946405829,13.461185775955467,6 +Random,95.0,98.94083225961137,12.927291869798962,6 +Random,100.0,99.11758778095916,12.695571646760456,6 +Random,105.0,99.19103550366009,12.53364639540295,6 +Random,110.0,99.3481107619468,12.362058785521928,6 +Random,115.0,99.47856267827952,12.152494665110453,6 +Random,120.0,99.4876199880963,12.11868756741673,6 +Random,5.0,15.133592805576457,14.376450289793278,7 +Random,10.0,16.311707141827917,14.679381058819876,7 +Random,15.0,17.401855498474877,14.79118498764925,7 +Random,20.0,18.383426775789154,14.706652640398984,7 +Random,25.0,19.657669403644643,14.742967250697712,7 +Random,30.0,20.76942945990279,14.535324053858787,7 +Random,35.0,22.09601779773871,14.361878020128781,7 +Random,40.0,24.00108338146133,14.399684112771663,7 +Random,45.0,26.14255146916728,14.378319140136476,7 +Random,50.0,28.492717530369543,14.24452407635477,7 +Random,55.0,31.858312524505912,14.323009076737067,7 +Random,60.0,36.19200426489684,14.615463924488143,7 +Random,65.0,42.31385759310079,15.026936867419833,7 +Random,70.0,49.205907985857124,15.07616107701259,7 +Random,75.0,58.32398678404799,14.997395410415221,7 +Random,80.0,71.42988695736872,14.925764724105465,7 +Random,85.0,91.11800348283874,14.722480887920202,7 +Random,90.0,98.04643794674203,13.688779003031238,7 +Random,95.0,98.85159076211318,13.151780864950332,7 +Random,100.0,98.99276719001946,12.967383201148532,7 +Random,105.0,99.09032752339606,12.805973251619085,7 +Random,110.0,99.24282115419831,12.590993594341102,7 +Random,115.0,99.41274184401561,12.351537070610087,7 +Random,120.0,99.46779515323371,12.236684438836583,7 +Random,5.0,14.867519356334633,14.12378438531386,8 +Random,10.0,15.789755184984305,14.191309363086472,8 +Random,15.0,16.940739535896913,14.399328624612659,8 +Random,20.0,18.108396362590998,14.485609364603077,8 +Random,25.0,19.362187673249487,14.5212043888273,8 +Random,30.0,20.4755631432242,14.331938322389682,8 +Random,35.0,21.821036110423144,14.181495583431822,8 +Random,40.0,23.49643408127803,14.095477520004618,8 +Random,45.0,25.74159372322844,14.153981329150486,8 +Random,50.0,28.521379391304848,14.25807263411785,8 +Random,55.0,31.485677543742746,14.205149645467575,8 +Random,60.0,34.6665971587189,13.99638747648507,8 +Random,65.0,39.27815072965524,13.99793117028863,8 +Random,70.0,45.742615205677076,14.127855595583439,8 +Random,75.0,53.78687065832699,14.13533160911766,8 +Random,80.0,64.69679428501762,14.015312787715924,8 +Random,85.0,82.11262762868803,13.998801861539922,8 +Random,90.0,96.22999609081016,13.152775351072673,8 +Random,95.0,98.79166022285136,12.302678755923324,8 +Random,100.0,99.03894111185204,11.987346916158952,8 +Random,105.0,99.1742414467181,11.780213985625315,8 +Random,110.0,99.29930138934444,11.60116999087521,8 +Random,115.0,99.38629509824298,11.453102577113377,8 +Random,120.0,99.46293796919662,11.344731176544531,8 +Random,5.0,15.026264785313279,14.274491953274065,9 +Random,10.0,16.08058633822462,14.471544023975799,9 +Random,15.0,17.04407063613308,14.486911294073185,9 +Random,20.0,18.13320950057196,14.504203160712642,9 +Random,25.0,19.374020172319327,14.52798889673151,9 +Random,30.0,20.6940796768806,14.484456624836358,9 +Random,35.0,22.123168207828712,14.378884086294667,9 +Random,40.0,23.85136233685074,14.338116691584885,9 +Random,45.0,25.787915374740223,14.212827731567659,9 +Random,50.0,28.221295348229937,14.14267602765736,9 +Random,55.0,31.309775875482316,14.127150306444122,9 +Random,60.0,35.39929154751667,14.24901264259809,9 +Random,65.0,41.13660631452998,14.500388841091988,9 +Random,70.0,47.1841061389561,14.580435682906892,9 +Random,75.0,55.8890170993365,14.691200082369269,9 +Random,80.0,66.9490246788358,14.418073841853435,9 +Random,85.0,84.46804394689511,14.082993096554977,9 +Random,90.0,97.82534209815248,13.029730851901405,9 +Random,95.0,98.90506546231835,12.441626739249774,9 +Random,100.0,99.1052557917991,12.187298124905569,9 +Random,105.0,99.23466280066484,11.971738730855499,9 +Random,110.0,99.34060887428735,11.821404522223247,9 +Random,115.0,99.44345832862432,11.653870448914248,9 +Random,120.0,99.45412084149018,11.601166298158518,9 +BestFit,5.0,15.182569731917505,14.423172397499574,0 +BestFit,10.0,15.503562150954794,13.952557042401608,0 +BestFit,15.0,15.749505709991027,13.385938952402624,0 +BestFit,20.0,16.270910922566017,13.015366717177127,0 +BestFit,25.0,16.741189181749853,12.555541539468596,0 +BestFit,30.0,17.343699224218252,12.140114822556757,0 +BestFit,35.0,17.9892594725547,11.69122320627955,0 +BestFit,40.0,18.813333174847568,11.285546781941466,0 +BestFit,45.0,19.890179240786367,10.93940646866008,0 +BestFit,50.0,21.147410711291332,10.57193512809098,0 +BestFit,55.0,22.537531908428125,10.139385994817014,0 +BestFit,60.0,24.286361629314552,9.711925227660858,0 +BestFit,65.0,26.56122791465197,9.292496040301819,0 +BestFit,70.0,29.600347940870737,8.879961431450175,0 +BestFit,75.0,34.02651031296558,8.506298925533939,0 +BestFit,80.0,40.422454041752545,8.078634367810022,0 +BestFit,85.0,50.6016905108605,7.584795892687961,0 +BestFit,90.0,71.92993626356248,7.191488331489183,0 +BestFit,95.0,99.58901407610121,6.843458216140568,0 +BestFit,100.0,99.61464816527761,6.813308388999201,0 +BestFit,105.0,99.61730035614576,6.800660775118188,0 +BestFit,110.0,99.62019934010027,6.767341905912557,0 +BestFit,115.0,99.62564226471869,6.740447712079606,0 +BestFit,120.0,99.63295968650795,6.698279612665196,0 +BestFit,5.0,15.50971653824871,14.73375633172546,1 +BestFit,10.0,15.763380133128582,14.18551957827034,1 +BestFit,15.0,16.085158453280073,13.6716855557352,1 +BestFit,20.0,16.64765260145365,13.317559298315798,1 +BestFit,25.0,17.20020423358737,12.89904562823409,1 +BestFit,30.0,17.93183014057479,12.550895509466844,1 +BestFit,35.0,18.611425144536383,12.096707293395765,1 +BestFit,40.0,19.34530725419677,11.604412729295897,1 +BestFit,45.0,20.379620573658237,11.207183779439758,1 +BestFit,50.0,21.500815477640085,10.728152387319541,1 +BestFit,55.0,22.976910537895908,10.338463115802897,1 +BestFit,60.0,24.70410477497496,9.879613723667518,1 +BestFit,65.0,27.136987580920007,9.496591425029981,1 +BestFit,70.0,30.245512553600882,9.07292343335602,1 +BestFit,75.0,34.41062241507418,8.602378634818011,1 +BestFit,80.0,40.840761763456,8.162564032102194,1 +BestFit,85.0,51.45630894470147,7.716292664898142,1 +BestFit,90.0,73.01942206403727,7.295242098455157,1 +BestFit,95.0,99.58772117336578,6.988133879502577,1 +BestFit,100.0,99.60513511959378,6.969633625633241,1 +BestFit,105.0,99.61495282398009,6.927184050370698,1 +BestFit,110.0,99.62731675403128,6.904307769254721,1 +BestFit,115.0,99.63246445103037,6.852538705200027,1 +BestFit,120.0,99.6598738296651,6.773726968506286,1 +BestFit,5.0,15.197541771706117,14.437053062798366,2 +BestFit,10.0,15.608130032951625,14.045306967836375,2 +BestFit,15.0,15.899440116976557,13.507485551406614,2 +BestFit,20.0,16.441047787305628,13.150985568310174,2 +BestFit,25.0,16.86523585959544,12.647868066302289,2 +BestFit,30.0,17.45962029883648,12.2206380643181,2 +BestFit,35.0,18.117619274082443,11.774731762639815,2 +BestFit,40.0,18.980438567436423,11.386185436304459,2 +BestFit,45.0,20.032303846270814,11.015155047497341,2 +BestFit,50.0,21.346704115409292,10.672596057236957,2 +BestFit,55.0,22.90897891400185,10.306532767311548,2 +BestFit,60.0,24.67773858890502,9.869625576695652,2 +BestFit,65.0,27.176664858425546,9.510782732714558,2 +BestFit,70.0,30.290627806590575,9.086993296080161,2 +BestFit,75.0,35.02935999287713,8.756945269436365,2 +BestFit,80.0,41.83852050854357,8.364808003218911,2 +BestFit,85.0,52.76666340085776,7.913555477163742,2 +BestFit,90.0,74.99438417775163,7.49557521704483,2 +BestFit,95.0,99.62851885185799,7.155707703820563,2 +BestFit,100.0,99.63566800255538,7.124784301901962,2 +BestFit,105.0,99.639594330039,7.08753180080718,2 +BestFit,110.0,99.64286975928277,7.067233095177442,2 +BestFit,115.0,99.64589779147262,7.013710938561389,2 +BestFit,120.0,99.64850571084554,7.0061946803394655,2 +BestFit,5.0,15.551297841877023,14.77188041269318,3 +BestFit,10.0,15.815135091162585,14.23308694290126,3 +BestFit,15.0,16.171946466759252,13.74485282687522,3 +BestFit,20.0,16.738445795404253,13.388385446320186,3 +BestFit,25.0,17.216768509734166,12.911523199423334,3 +BestFit,30.0,17.81862402016056,12.47217628816165,3 +BestFit,35.0,18.626867159863068,12.105484624238521,3 +BestFit,40.0,19.5208067319426,11.708713117066685,3 +BestFit,45.0,20.491573873855604,11.269870824425963,3 +BestFit,50.0,21.642560016994118,10.819015413517837,3 +BestFit,55.0,23.18806735196597,10.431532095908508,3 +BestFit,60.0,25.143643631644085,10.053450336238573,3 +BestFit,65.0,27.686660872921642,9.68779083599625,3 +BestFit,70.0,31.15250569821521,9.344297390943563,3 +BestFit,75.0,35.73367142383133,8.93140452933222,3 +BestFit,80.0,42.61779361527665,8.523215695096424,3 +BestFit,85.0,54.57833078741429,8.179545137872987,3 +BestFit,90.0,76.92604721246376,7.6901280294494585,3 +BestFit,95.0,99.59772929418533,7.388381457396383,3 +BestFit,100.0,99.61582044322971,7.361660446051725,3 +BestFit,105.0,99.62295297862931,7.333320622752364,3 +BestFit,110.0,99.63708129022079,7.247907967389701,3 +BestFit,115.0,99.65658578730506,7.20922030281697,3 +BestFit,120.0,99.66857478696933,7.145588613510066,3 +BestFit,5.0,15.396791790170102,14.626803487283063,4 +BestFit,10.0,15.725654268667858,14.152658487450509,4 +BestFit,15.0,16.022450960222205,13.618257948463947,4 +BestFit,20.0,16.64014843452358,13.310511521433924,4 +BestFit,25.0,17.163667017700526,12.87186610785914,4 +BestFit,30.0,17.737381745790305,12.415196405924172,4 +BestFit,35.0,18.425557727706163,11.976078620821173,4 +BestFit,40.0,19.257280960899305,11.55222956754685,4 +BestFit,45.0,20.236206665114466,11.118577220353453,4 +BestFit,50.0,21.395691275915905,10.696399052263207,4 +BestFit,55.0,22.905532589817685,10.304281710918117,4 +BestFit,60.0,24.607517004309134,9.840748867935444,4 +BestFit,65.0,26.972089070304,9.43788653067564,4 +BestFit,70.0,29.995961269326155,8.998015786817959,4 +BestFit,75.0,34.51388064316217,8.625969960164433,4 +BestFit,80.0,41.07685964879767,8.212462429076114,4 +BestFit,85.0,51.91008683843534,7.782418379507938,4 +BestFit,90.0,73.60803546063963,7.35689326729675,4 +BestFit,95.0,99.6044686307926,7.030997986896725,4 +BestFit,100.0,99.62735686688289,6.975518769427229,4 +BestFit,105.0,99.6450808847981,6.931685254788747,4 +BestFit,110.0,99.65327997912668,6.884450274153591,4 +BestFit,115.0,99.66042167620401,6.81435352655627,4 +BestFit,120.0,99.66890367433284,6.789262168350588,4 +BestFit,5.0,15.196747556728196,14.436200736394762,5 +BestFit,10.0,15.494164327336401,13.942378374945482,5 +BestFit,15.0,15.75163808354196,13.387244179646496,5 +BestFit,20.0,16.22861210431499,12.982132069557876,5 +BestFit,25.0,16.77687205641311,12.581897840736145,5 +BestFit,30.0,17.334953901394428,12.132737584257029,5 +BestFit,35.0,18.192821284052485,11.824865249411117,5 +BestFit,40.0,19.098916734628883,11.457689800108216,5 +BestFit,45.0,20.144159429384636,11.07604490454062,5 +BestFit,50.0,21.31503686587846,10.655082232653553,5 +BestFit,55.0,22.822803462637957,10.243588416986398,5 +BestFit,60.0,24.464166393177035,9.7832642485941,5 +BestFit,65.0,26.795208660114422,9.37819362726352,5 +BestFit,70.0,29.778842727233496,8.931735313808991,5 +BestFit,75.0,34.00233099062188,8.49614908891394,5 +BestFit,80.0,40.45544618908458,8.088744749628244,5 +BestFit,85.0,51.442246743514296,7.714929223061858,5 +BestFit,90.0,73.31950337650035,7.3228621184613765,5 +BestFit,95.0,99.62194967746943,7.039608987511563,5 +BestFit,100.0,99.63013964192297,7.006186445778731,5 +BestFit,105.0,99.63720557963433,6.984548863764877,5 +BestFit,110.0,99.65454046619455,6.943733305761025,5 +BestFit,115.0,99.66644696406306,6.900280990068268,5 +BestFit,120.0,99.67752434482682,6.882915979992483,5 +BestFit,5.0,15.28272173498616,14.518487240498693,6 +BestFit,10.0,15.491003727672176,13.93339976142276,6 +BestFit,15.0,15.78368262894933,13.413970522721122,6 +BestFit,20.0,16.352432892689396,13.081577778960746,6 +BestFit,25.0,16.81505193292538,12.611099469070181,6 +BestFit,30.0,17.344319880465477,12.137868880674679,6 +BestFit,35.0,18.20522106681421,11.819883379662675,6 +BestFit,40.0,18.92915417280444,11.354445312090153,6 +BestFit,45.0,19.912956144941376,10.95193354594947,6 +BestFit,50.0,21.15680120638083,10.57829842932756,6 +BestFit,55.0,22.677222184447206,10.203508795695612,6 +BestFit,60.0,24.57109320133657,9.826815556739966,6 +BestFit,65.0,26.93286198961795,9.425244367007473,6 +BestFit,70.0,29.79515731876402,8.93379877229605,6 +BestFit,75.0,34.07530469528363,8.516906283826811,6 +BestFit,80.0,40.68222936716717,8.128783573311162,6 +BestFit,85.0,51.28284713072344,7.689867880521188,6 +BestFit,90.0,72.88061682522984,7.280787699517258,6 +BestFit,95.0,99.6011594787554,6.9645453385040055,6 +BestFit,100.0,99.62433199624977,6.923666550132138,6 +BestFit,105.0,99.63434781088033,6.885548215584486,6 +BestFit,110.0,99.64670403724485,6.8658696493917315,6 +BestFit,115.0,99.6646054678302,6.847369119062324,6 +BestFit,120.0,99.68123757717392,6.811925654199295,6 +BestFit,5.0,15.051211387100189,14.297027457856343,7 +BestFit,10.0,15.536330751962577,13.981572218163866,7 +BestFit,15.0,15.84699099703962,13.467569890685995,7 +BestFit,20.0,16.419200594632635,13.134620395833837,7 +BestFit,25.0,16.90153726683294,12.674819763830323,7 +BestFit,30.0,17.561317567886125,12.29213073781022,7 +BestFit,35.0,18.249623058974134,11.860815465587097,7 +BestFit,40.0,19.107581285917156,11.464271939239351,7 +BestFit,45.0,20.05755555620199,11.009021385845282,7 +BestFit,50.0,21.142453404507805,10.56846987880614,7 +BestFit,55.0,22.772179803909616,10.246271185530222,7 +BestFit,60.0,24.523138705106575,9.808979142746221,7 +BestFit,65.0,26.933212497793946,9.423502688297686,7 +BestFit,70.0,30.324144894265288,9.093191787619213,7 +BestFit,75.0,34.62867942349446,8.65454984954248,7 +BestFit,80.0,41.537739439126064,8.30159673069373,7 +BestFit,85.0,52.49180969029992,7.873686952885488,7 +BestFit,90.0,74.01828202484084,7.390508600435866,7 +BestFit,95.0,99.62871261548291,7.081785953395449,7 +BestFit,100.0,99.65138115006894,7.020513594094667,7 +BestFit,105.0,99.6605379732712,6.985221866317157,7 +BestFit,110.0,99.66573771821231,6.964247709488782,7 +BestFit,115.0,99.67231221393207,6.950106046134373,7 +BestFit,120.0,99.68172911259134,6.920755465062689,7 +BestFit,5.0,15.175536979309513,14.415123361223595,8 +BestFit,10.0,15.48691483403584,13.936877095962199,8 +BestFit,15.0,15.770305222098497,13.402855425757885,8 +BestFit,20.0,16.296082935316697,13.03634168363857,8 +BestFit,25.0,16.762060340876587,12.571437322236065,8 +BestFit,30.0,17.296687606690288,12.106177749134654,8 +BestFit,35.0,18.120233197749442,11.773951138130723,8 +BestFit,40.0,18.949174571001965,11.366484832294484,8 +BestFit,45.0,19.806647891707772,10.892094000216028,8 +BestFit,50.0,20.917660005207818,10.433676280736751,8 +BestFit,55.0,22.19034689303241,9.985477493148458,8 +BestFit,60.0,23.785054758180884,9.513409281127917,8 +BestFit,65.0,26.09846905139925,9.131271180790925,8 +BestFit,70.0,29.14200449254467,8.742272960719864,8 +BestFit,75.0,33.27520717128977,8.302035630806005,8 +BestFit,80.0,39.15902556471332,7.831742075232485,8 +BestFit,85.0,48.95948055294245,7.338877963888911,8 +BestFit,90.0,68.76962836925226,6.875302269594993,8 +BestFit,95.0,99.62156714264464,6.5310500996203915,8 +BestFit,100.0,99.63786476608651,6.505813639370926,8 +BestFit,105.0,99.65029268187183,6.463473265837033,8 +BestFit,110.0,99.65321086735382,6.446497551037665,8 +BestFit,115.0,99.65649603433545,6.434678132545363,8 +BestFit,120.0,99.65828101253673,6.408483086488695,8 +BestFit,5.0,15.323892209376371,14.556809543338428,9 +BestFit,10.0,15.625352429085195,14.061609818313508,9 +BestFit,15.0,15.920893152736268,13.53160586335469,9 +BestFit,20.0,16.39314924770679,13.112592965623431,9 +BestFit,25.0,16.88910341832588,12.666582872935061,9 +BestFit,30.0,17.49066233558862,12.24084510368665,9 +BestFit,35.0,18.22038597296371,11.841579018291766,9 +BestFit,40.0,19.015548107635873,11.408624811770093,9 +BestFit,45.0,20.12508595778106,11.065622359806227,9 +BestFit,50.0,21.330503169252598,10.661817826872099,9 +BestFit,55.0,22.74087709728002,10.22837940053339,9 +BestFit,60.0,24.42925829913288,9.769461742507241,9 +BestFit,65.0,26.894500876477128,9.410607524168874,9 +BestFit,70.0,30.081561523296152,9.019771239558454,9 +BestFit,75.0,34.52231311857441,8.630078117347937,9 +BestFit,80.0,41.27414214258657,8.253167363556651,9 +BestFit,85.0,52.09801985537271,7.811096708418955,9 +BestFit,90.0,73.44469628704283,7.338794571682758,9 +BestFit,95.0,99.619846250962,6.972908137215174,9 +BestFit,100.0,99.63591098455656,6.911479459490525,9 +BestFit,105.0,99.64111347723946,6.8982062559596695,9 +BestFit,110.0,99.651293465205,6.847577451474128,9 +BestFit,115.0,99.66109899697734,6.83365182191925,9 +BestFit,120.0,99.6704501263983,6.797069025603022,9 +DotProd,5.0,15.888053196086679,15.093369195997145,0 +DotProd,10.0,16.89457263557013,15.20440825854157,0 +DotProd,15.0,17.266528435691246,14.675298375457308,0 +DotProd,20.0,17.81060540600923,14.246993417722523,0 +DotProd,25.0,18.51359870160011,13.884811587721138,0 +DotProd,30.0,19.366194759309423,13.55580634872378,0 +DotProd,35.0,20.39388963611666,13.253992814091706,0 +DotProd,40.0,21.517019535762387,12.90740605728748,0 +DotProd,45.0,23.316688713296273,12.82395358282766,0 +DotProd,50.0,25.19339376555293,12.5945879702269,0 +DotProd,55.0,27.28197581257421,12.273858760972225,0 +DotProd,60.0,30.000458119131157,11.996947525350526,0 +DotProd,65.0,33.37822616242194,11.677435826508125,0 +DotProd,70.0,38.092034294576,11.427426328129927,0 +DotProd,75.0,44.556663458299646,11.13873550401352,0 +DotProd,80.0,55.202779192917816,11.032558011591702,0 +DotProd,85.0,71.58381202103232,10.729851076488107,0 +DotProd,90.0,99.54502180674505,10.308165836707166,0 +DotProd,95.0,99.57021249260852,10.2638103457046,0 +DotProd,100.0,99.57264392920473,10.232163112074675,0 +DotProd,105.0,99.5744290755464,10.219523061351358,0 +DotProd,110.0,99.57647670220211,10.186231147002799,0 +DotProd,115.0,99.5799411271053,10.159334109580534,0 +DotProd,120.0,99.58502056241169,10.117209671110436,0 +DotProd,5.0,15.977394592944286,15.178036179302746,1 +DotProd,10.0,16.742991573048894,15.067075256223095,1 +DotProd,15.0,17.352241848144796,14.748651368524646,1 +DotProd,20.0,17.844311594916643,14.274846039385494,1 +DotProd,25.0,18.620792321919115,13.964395220684533,1 +DotProd,30.0,19.576866532469754,13.702293872159691,1 +DotProd,35.0,20.594157812264303,13.385406924740192,1 +DotProd,40.0,21.67614468882258,13.002581248455671,1 +DotProd,45.0,23.33440374158087,12.832081449718613,1 +DotProd,50.0,24.88781956405637,12.418148565061555,1 +DotProd,55.0,27.139397615552813,12.211374578437809,1 +DotProd,60.0,29.80256089225415,11.918577591599842,1 +DotProd,65.0,33.476415333319295,11.71507477929002,1 +DotProd,70.0,38.241388806536456,11.471493234311085,1 +DotProd,75.0,44.49864097331464,11.12430207654686,1 +DotProd,80.0,54.14833360859919,10.822257500282753,1 +DotProd,85.0,70.789361630491,10.615441392992238,1 +DotProd,90.0,99.53266094374693,10.166207025466528,1 +DotProd,95.0,99.57979848377515,10.102732839412381,1 +DotProd,100.0,99.5825977726843,10.083299098360998,1 +DotProd,105.0,99.58428586087844,10.040346760709411,1 +DotProd,110.0,99.58601752434231,10.016795127130539,1 +DotProd,115.0,99.59098424064172,9.965190596313297,1 +DotProd,120.0,99.59670127762237,9.88511689837705,1 +DotProd,5.0,15.934392272652612,15.137031384379245,2 +DotProd,10.0,16.68942222109076,15.018330685109033,2 +DotProd,15.0,17.23742109239541,14.644177067621076,2 +DotProd,20.0,17.734409079429774,14.185528859429894,2 +DotProd,25.0,18.491826015424937,13.867708563058384,2 +DotProd,30.0,19.3854601434656,13.568605048034438,2 +DotProd,35.0,20.250898341533926,13.161160543049633,2 +DotProd,40.0,21.432074224334876,12.856898460796609,2 +DotProd,45.0,23.047058742527714,12.672877138142121,2 +DotProd,50.0,24.98435133047774,12.491290836312183,2 +DotProd,55.0,27.500773372350416,12.37233763026002,2 +DotProd,60.0,30.440610570128136,12.17443112020984,2 +DotProd,65.0,34.19420076983631,11.966649179908796,2 +DotProd,70.0,39.082974249629466,11.724640613753962,2 +DotProd,75.0,46.13161217795326,11.53238320983727,2 +DotProd,80.0,56.87875121754643,11.371813047272433,2 +DotProd,85.0,74.29506381741618,11.142226385096542,2 +DotProd,90.0,99.5767339884974,10.731909756165354,2 +DotProd,95.0,99.58380039503622,10.681532846300186,2 +DotProd,100.0,99.58665778447578,10.650417916792764,2 +DotProd,105.0,99.5913467963317,10.613404296947795,2 +DotProd,110.0,99.59422928845706,10.593189812904438,2 +DotProd,115.0,99.59759380419418,10.523803705923553,2 +DotProd,120.0,99.60031312089673,10.484327873431184,2 +DotProd,5.0,16.02423598831156,15.221115313391895,3 +DotProd,10.0,17.117517814847762,15.4051873664697,3 +DotProd,15.0,17.597861194346514,14.956765574338585,3 +DotProd,20.0,18.16948051248046,14.533010497741769,3 +DotProd,25.0,18.935530557135348,14.200489594990628,3 +DotProd,30.0,19.875594117011104,13.911956017414036,3 +DotProd,35.0,20.99340167637676,13.643480625204091,3 +DotProd,40.0,22.3661794003044,13.415387064638493,3 +DotProd,45.0,23.742000563830796,13.057527016468102,3 +DotProd,50.0,25.469283533958496,12.731976758238597,3 +DotProd,55.0,27.499084443456272,12.3709137818979,3 +DotProd,60.0,30.207690163421557,12.078261897103715,3 +DotProd,65.0,33.70858648798996,11.794912242094298,3 +DotProd,70.0,38.41839688305881,11.523725546711603,3 +DotProd,75.0,45.05261984109133,11.260616580210984,3 +DotProd,80.0,55.120106988034344,11.023577739308552,3 +DotProd,85.0,72.34215502458541,10.841773902895827,3 +DotProd,90.0,99.56186047601963,10.385879138291308,3 +DotProd,95.0,99.58152370918381,10.324128898008011,3 +DotProd,100.0,99.58459044456582,10.296392587046983,3 +DotProd,105.0,99.58884683702587,10.26797563138739,3 +DotProd,110.0,99.59493176698993,10.182186931084638,3 +DotProd,115.0,99.60108543903631,10.142731912086303,3 +DotProd,120.0,99.60632775302825,10.078807056619626,3 +DotProd,5.0,16.051450327112967,15.248722774211968,4 +DotProd,10.0,16.64046106063722,14.975959565265645,4 +DotProd,15.0,17.452235379929363,14.833501052443888,4 +DotProd,20.0,18.039694091591507,14.430012868821319,4 +DotProd,25.0,18.748918624558904,14.06072315161944,4 +DotProd,30.0,19.559006021599533,13.690233696438517,4 +DotProd,35.0,20.616128799805434,13.399886343314654,4 +DotProd,40.0,22.074525827493385,13.242263561077364,4 +DotProd,45.0,23.61354410812946,12.97422080913378,4 +DotProd,50.0,25.360008384287593,12.678289574706387,4 +DotProd,55.0,27.55723445459234,12.396896072181601,4 +DotProd,60.0,30.420971543451714,12.16559725328223,4 +DotProd,65.0,33.78905478788095,11.823231943049809,4 +DotProd,70.0,38.28773989789227,11.485335807361313,4 +DotProd,75.0,45.21560101398895,11.300624815561603,4 +DotProd,80.0,54.46014170406047,10.888170893556838,4 +DotProd,85.0,70.31370604950158,10.541509591268765,4 +DotProd,90.0,99.56786815246036,10.093989157709855,4 +DotProd,95.0,99.58143706674232,10.046632040964083,4 +DotProd,100.0,99.5853817190305,9.989959187384287,4 +DotProd,105.0,99.59057309839521,9.945430138697617,4 +DotProd,110.0,99.59356920551993,9.897952643337405,4 +DotProd,115.0,99.5983144807761,9.827878111281622,4 +DotProd,120.0,99.60651926657117,9.803032466838978,4 +DotProd,5.0,15.81019955446274,15.018951495949059,5 +DotProd,10.0,16.205740184681847,14.582687825393409,5 +DotProd,15.0,17.17806979954832,14.599561881874662,5 +DotProd,20.0,17.66406382947705,14.130426437292106,5 +DotProd,25.0,18.38283906309014,13.786300708306396,5 +DotProd,30.0,19.31186666972176,13.516379212698476,5 +DotProd,35.0,20.451118912398204,13.29270054176685,5 +DotProd,40.0,21.683845435541137,13.008422316615247,5 +DotProd,45.0,23.193464946551664,12.75267206558951,5 +DotProd,50.0,24.8601327063359,12.42722496646136,5 +DotProd,55.0,27.052279236417498,12.141909502611913,5 +DotProd,60.0,29.45428459746241,11.778821515481376,5 +DotProd,65.0,32.93137592402503,11.525822535856015,5 +DotProd,70.0,37.56594132373671,11.267363469798184,5 +DotProd,75.0,45.20462749769189,11.295262517006194,5 +DotProd,80.0,55.4939659480716,11.095577183860751,5 +DotProd,85.0,72.61895500996825,10.890855933022687,5 +DotProd,90.0,99.56488930872848,10.496306295959464,5 +DotProd,95.0,99.57936870627941,10.465451811587517,5 +DotProd,100.0,99.58272348686813,10.431819298429595,5 +DotProd,105.0,99.58670070617069,10.4101126803862,5 +DotProd,110.0,99.5927191628223,10.36873715250544,5 +DotProd,115.0,99.59794693701376,10.325029920878658,5 +DotProd,120.0,99.60492323538023,10.307634401459156,5 +DotProd,5.0,15.918214875184516,15.122201631651455,6 +DotProd,10.0,16.161760478730777,14.536712633814478,6 +DotProd,15.0,17.13547527043832,14.56280929957961,6 +DotProd,20.0,17.892127459962037,14.313298732643725,6 +DotProd,25.0,18.831106639198854,14.12311778083751,6 +DotProd,30.0,19.62410413783568,13.733303154425117,6 +DotProd,35.0,20.96140073374133,13.609354769046734,6 +DotProd,40.0,21.94840315683072,13.1655086675761,6 +DotProd,45.0,23.307805859267376,12.8190680989088,6 +DotProd,50.0,25.478282954233165,12.739018433251722,6 +DotProd,55.0,27.755923149904245,12.488646258752652,6 +DotProd,60.0,30.428880017111226,12.169543661576157,6 +DotProd,65.0,34.114325910203256,11.938421480915983,6 +DotProd,70.0,38.261824650868114,11.472449647931999,6 +DotProd,75.0,44.887733488792385,11.219404282255898,6 +DotProd,80.0,54.35494141321387,10.860750793677338,6 +DotProd,85.0,70.05310331940305,10.504469608981161,6 +DotProd,90.0,99.55124902694331,10.044868462667122,6 +DotProd,95.0,99.58896808730479,10.017733175903775,6 +DotProd,100.0,99.59889399629496,9.976243371277326,6 +DotProd,105.0,99.60321395106362,9.937873793765187,6 +DotProd,110.0,99.60622013630012,9.917649594124994,6 +DotProd,115.0,99.61395670515685,9.882660234678237,6 +DotProd,120.0,99.61771819221657,9.846470564585156,6 +DotProd,5.0,15.815292739340583,15.022822331907445,7 +DotProd,10.0,16.77176751719379,15.093375811291734,7 +DotProd,15.0,17.155223366083163,14.579371548593354,7 +DotProd,20.0,17.752194467213407,14.200955410465685,7 +DotProd,25.0,18.468793298266846,13.85013816289585,7 +DotProd,30.0,19.5206715262553,13.663590192649904,7 +DotProd,35.0,20.48635722841786,13.314516243056005,7 +DotProd,40.0,21.789113572274058,13.073152460778903,7 +DotProd,45.0,23.541777746086463,12.921411781274811,7 +DotProd,50.0,25.079838082091864,12.536648811032036,7 +DotProd,55.0,27.601963990761536,12.419417497047332,7 +DotProd,60.0,30.4756025860912,12.189897619726102,7 +DotProd,65.0,34.063211770587245,11.918176033344501,7 +DotProd,70.0,38.63382862510554,11.58498663039084,7 +DotProd,75.0,45.27535761422969,11.315413869417275,7 +DotProd,80.0,55.47488048145841,11.087028149796453,7 +DotProd,85.0,72.73296239646587,10.909827274855619,7 +DotProd,90.0,99.56305408444479,10.453319302063079,7 +DotProd,95.0,99.58480096568351,10.400936713865999,7 +DotProd,100.0,99.58954505415528,10.33858754258271,7 +DotProd,105.0,99.59705610364303,10.303453337805102,7 +DotProd,110.0,99.60216674379755,10.282657043539105,7 +DotProd,115.0,99.606496323139,10.26851259583682,7 +DotProd,120.0,99.60874736404979,10.238759409910948,7 +DotProd,5.0,15.984521667781054,15.183571561610695,8 +DotProd,10.0,17.072094325758492,15.36340084119682,8 +DotProd,15.0,17.48127314072974,14.856971584485775,8 +DotProd,20.0,17.959526433272973,14.367042926192317,8 +DotProd,25.0,18.68158378580199,14.011067545830654,8 +DotProd,30.0,19.751201827524515,13.824124336416736,8 +DotProd,35.0,20.89348964259319,13.575924960363425,8 +DotProd,40.0,22.091488573612214,13.251372446535692,8 +DotProd,45.0,23.40433382627638,12.870537480244874,8 +DotProd,50.0,25.390204342901253,12.664570164618471,8 +DotProd,55.0,27.33504188129035,12.300548828535918,8 +DotProd,60.0,30.161007019077918,12.063625962633912,8 +DotProd,65.0,33.77563606515929,11.817340381432702,8 +DotProd,70.0,38.32584417871182,11.497321378357203,8 +DotProd,75.0,45.12056823367215,11.257407451436187,8 +DotProd,80.0,54.593492365031224,10.918610589084238,8 +DotProd,85.0,69.89510635398909,10.477064911877124,8 +DotProd,90.0,99.54172789167248,10.010417390728716,8 +DotProd,95.0,99.56355018648325,9.975267605451304,8 +DotProd,100.0,99.57085552041211,9.949712307749623,8 +DotProd,105.0,99.57350804736649,9.906858765079669,8 +DotProd,110.0,99.57523644634803,9.873849669385304,8 +DotProd,115.0,99.57782318454244,9.846053820772944,8 +DotProd,120.0,99.57988769061234,9.819968351640735,8 +DotProd,5.0,15.989192053330619,15.188805839405353,9 +DotProd,10.0,16.590383291314016,14.93006302657735,9 +DotProd,15.0,17.462487327639614,14.841849238265498,9 +DotProd,20.0,17.9130155417303,14.32830739453273,9 +DotProd,25.0,18.60838439681095,13.956018697705485,9 +DotProd,30.0,19.385415430489243,13.566888606179827,9 +DotProd,35.0,20.60397682962275,13.390694361857374,9 +DotProd,40.0,22.062677771669822,13.236789789871287,9 +DotProd,45.0,23.9301213769753,13.157791561111484,9 +DotProd,50.0,25.79352345689525,12.892609519262704,9 +DotProd,55.0,28.10635581914349,12.641661517926858,9 +DotProd,60.0,30.84308660048169,12.334404543708112,9 +DotProd,65.0,34.740039993246114,12.155826324938783,9 +DotProd,70.0,39.37496426868444,11.806340904021221,9 +DotProd,75.0,46.353274856816846,11.587647143898838,9 +DotProd,80.0,56.81482072478919,11.360677650240996,9 +DotProd,85.0,73.94010667519044,11.085897803295614,9 +DotProd,90.0,99.58331777814776,10.648778251849702,9 +DotProd,95.0,99.59978446903276,10.581915929123804,9 +DotProd,100.0,99.60408478898422,10.519839663426401,9 +DotProd,105.0,99.60852909868942,10.490644571398374,9 +DotProd,110.0,99.61225717420793,10.439723746087646,9 +DotProd,115.0,99.61560613468127,10.409445977174144,9 +DotProd,120.0,99.61670830215677,10.356321054188019,9 +Packing,5.0,14.031996024834104,13.330147749741347,0 +Packing,10.0,14.360989100145074,12.924289118468302,0 +Packing,15.0,14.633775747422295,12.437649308186218,0 +Packing,20.0,15.274027401940248,12.217943348749706,0 +Packing,25.0,15.726796222427447,11.794768048419275,0 +Packing,30.0,16.1943751279283,11.335619408002527,0 +Packing,35.0,16.7928225458882,10.91365861651788,0 +Packing,40.0,17.495277154068813,10.494885034473697,0 +Packing,45.0,18.326656473148482,10.079484048095756,0 +Packing,50.0,19.396615229340917,9.696683944367955,0 +Packing,55.0,20.559160235469108,9.249338490287824,0 +Packing,60.0,21.982317302740114,8.790556001489996,0 +Packing,65.0,23.83657067699632,8.33926953008735,0 +Packing,70.0,26.382474736421646,7.914615010391711,0 +Packing,75.0,30.21006710776183,7.552224986208575,0 +Packing,80.0,35.37442795504024,7.069760512907671,0 +Packing,85.0,43.86347004247276,6.574789578339929,0 +Packing,90.0,62.10492598065086,6.2091929135226565,0 +Packing,95.0,99.37559926989366,5.785445182864917,0 +Packing,100.0,99.40760629965989,5.751782989743495,0 +Packing,105.0,99.42596227542144,5.740040703611433,0 +Packing,110.0,99.4717854592337,5.709219315459596,0 +Packing,115.0,99.52698863903568,5.685150780533685,0 +Packing,120.0,99.59968426853341,5.646654347342551,0 +Packing,5.0,13.948206097098193,13.250369172932523,1 +Packing,10.0,14.225664531252907,12.80172406030426,1 +Packing,15.0,14.589100813810429,12.400101587228276,1 +Packing,20.0,15.228916757140787,12.182618583993527,1 +Packing,25.0,15.649796595337168,11.736339732620364,1 +Packing,30.0,16.151732043834045,11.304964389572909,1 +Packing,35.0,16.649714869232508,10.821671404928932,1 +Packing,40.0,17.332659945746094,10.39711269839556,1 +Packing,45.0,18.156061079855395,9.984401451304716,1 +Packing,50.0,18.96483331096626,9.46278628230389,1 +Packing,55.0,20.073202563315775,9.031939432179385,1 +Packing,60.0,21.53389732284727,8.61179101419451,1 +Packing,65.0,23.319340472545676,8.160605450718341,1 +Packing,70.0,25.727847162992347,7.717732903393126,1 +Packing,75.0,29.210273880907984,7.3023333585569965,1 +Packing,80.0,34.384234975045516,6.872142133494491,1 +Packing,85.0,42.515454428212244,6.375538702198456,1 +Packing,90.0,60.26240162086716,6.020710611390649,1 +Packing,95.0,99.3650463228485,5.653346478088247,1 +Packing,100.0,99.40313278263854,5.635831192215895,1 +Packing,105.0,99.4455296436464,5.595171774911576,1 +Packing,110.0,99.51684558060839,5.575474527916773,1 +Packing,115.0,99.55834112418633,5.525712307275729,1 +Packing,120.0,99.61582688304146,5.448241658646684,1 +Packing,5.0,13.99483205220461,13.294527231949004,2 +Packing,10.0,14.270920423404263,12.841990529109767,2 +Packing,15.0,14.562586105820131,12.371751455917645,2 +Packing,20.0,15.20143588014397,12.159435728404262,2 +Packing,25.0,15.594574318845458,11.69495168504774,2 +Packing,30.0,16.07467708728273,11.251264765337435,2 +Packing,35.0,16.645755654879967,10.8181602040306,2 +Packing,40.0,17.320561915039843,10.390441144178105,2 +Packing,45.0,18.09545749378564,9.950142104426622,2 +Packing,50.0,19.097544841066057,9.548096074772419,2 +Packing,55.0,20.34035609129558,9.150933672805166,2 +Packing,60.0,21.892714410233907,8.755781787221105,2 +Packing,65.0,23.909202741789816,8.367297229964814,2 +Packing,70.0,26.470281373515025,7.940913965941351,2 +Packing,75.0,30.21996725149645,7.554651278793692,2 +Packing,80.0,35.743290560977755,7.1461839307819615,2 +Packing,85.0,44.633358084799355,6.693782258941019,2 +Packing,90.0,62.77879068317862,6.27464513190146,2 +Packing,95.0,99.3794697782308,5.826625352210126,2 +Packing,100.0,99.39599710402311,5.796233089332297,2 +Packing,105.0,99.42513331146034,5.760479673233668,2 +Packing,110.0,99.45960115308549,5.741982736885206,2 +Packing,115.0,99.49146227603094,5.674152487951078,2 +Packing,120.0,99.53251112601372,5.636757471688905,2 +Packing,5.0,13.999982090624652,13.298315248368523,3 +Packing,10.0,14.245354792966639,12.820337741791924,3 +Packing,15.0,14.58141863117341,12.39303218721929,3 +Packing,20.0,15.096331709071734,12.074926801271548,3 +Packing,25.0,15.465978083305535,11.598537478823054,3 +Packing,30.0,15.935449646161837,11.154045171680021,3 +Packing,35.0,16.57147976839735,10.769701196424306,3 +Packing,40.0,17.300760654910246,10.37711432714032,3 +Packing,45.0,18.038585352163146,9.920786369349303,3 +Packing,50.0,18.919339053230512,9.457689879096822,3 +Packing,55.0,20.06306066886326,9.025696628040127,3 +Packing,60.0,21.59539955037326,8.634718183710985,3 +Packing,65.0,23.424367080267913,8.196379107643722,3 +Packing,70.0,25.942062322545134,7.781407621735611,3 +Packing,75.0,29.493460198014574,7.371703312370793,3 +Packing,80.0,34.93885207499326,6.987489194360576,3 +Packing,85.0,44.14029895918761,6.615218210725122,3 +Packing,90.0,61.703040183375805,6.168317442671651,3 +Packing,95.0,99.38287663062016,5.769710339353943,3 +Packing,100.0,99.39833158563235,5.7426057989001,3 +Packing,105.0,99.43303080887421,5.7157986110014045,3 +Packing,110.0,99.4720807892228,5.679772546029809,3 +Packing,115.0,99.53543558570671,5.659355416753293,3 +Packing,120.0,99.57090307012207,5.6129650413868655,3 +Packing,5.0,14.056387088652158,13.353431967441487,4 +Packing,10.0,14.250410894036206,12.82497982236408,4 +Packing,15.0,14.592664217180365,12.403012869769205,4 +Packing,20.0,15.24128302541497,12.1915543067107,4 +Packing,25.0,15.68644107307888,11.764022746028822,4 +Packing,30.0,16.115092079439506,11.27968243189435,4 +Packing,35.0,16.65489439097106,10.825198758994329,4 +Packing,40.0,17.3795791611304,10.425817054047688,4 +Packing,45.0,18.212885171026926,10.00688387555306,4 +Packing,50.0,19.01078782336253,9.50410857187353,4 +Packing,55.0,20.276034302143948,9.121375746679087,4 +Packing,60.0,21.57545641873588,8.628202849181646,4 +Packing,65.0,23.429426841810194,8.198262709106444,4 +Packing,70.0,25.824456552902053,7.746671815669649,4 +Packing,75.0,29.212296405966427,7.300957949949005,4 +Packing,80.0,34.30081153421382,6.857732758054133,4 +Packing,85.0,42.77410190689312,6.412741282503008,4 +Packing,90.0,60.007833826771304,5.9975955872549065,4 +Packing,95.0,99.34942183168374,5.603838363748156,4 +Packing,100.0,99.37133115105617,5.548126011448919,4 +Packing,105.0,99.39334259156853,5.504394352600012,4 +Packing,110.0,99.42243931683227,5.458311124374169,4 +Packing,115.0,99.46509939360367,5.390201394053863,4 +Packing,120.0,99.51472772457079,5.3672592364520355,4 +Packing,5.0,13.963528092182417,13.264699816493659,5 +Packing,10.0,14.187868927895083,12.766912286959817,5 +Packing,15.0,14.402972589563506,12.241019628981013,5 +Packing,20.0,15.106820413452304,12.08475108640899,5 +Packing,25.0,15.48156576355175,11.610476505791025,5 +Packing,30.0,15.907662627602488,11.133776146013782,5 +Packing,35.0,16.484266273210878,10.714348498932283,5 +Packing,40.0,17.173939931541625,10.302871053650847,5 +Packing,45.0,17.793058915388997,9.78331809906677,5 +Packing,50.0,18.694994324335713,9.345360419416698,5 +Packing,55.0,19.846052605282566,8.907529476962752,5 +Packing,60.0,21.124951751302945,8.447906292831508,5 +Packing,65.0,22.93299596855154,8.02643783724175,5 +Packing,70.0,25.143794182536826,7.54151920812985,5 +Packing,75.0,28.57709792174916,7.140548232961982,5 +Packing,80.0,33.519131675455235,6.701883822630782,5 +Packing,85.0,41.87642508913403,6.280317756888268,5 +Packing,90.0,58.89293268018545,5.881993274753284,5 +Packing,95.0,99.36413328604011,5.466786837277814,5 +Packing,100.0,99.39692001176012,5.428748715645497,5 +Packing,105.0,99.42958492693329,5.408444421572862,5 +Packing,110.0,99.49417433591206,5.36999465089254,5 +Packing,115.0,99.54183693983737,5.3283405697415605,5 +Packing,120.0,99.58655465288093,5.312618858084041,5 +Packing,5.0,14.018406751582157,13.317396147378766,6 +Packing,10.0,14.21440334625924,12.785160192024378,6 +Packing,15.0,14.513208870270669,12.334241669231076,6 +Packing,20.0,15.265422530551554,12.211993987230297,6 +Packing,25.0,15.673409366549334,11.75488040890174,6 +Packing,30.0,16.083313494706562,11.255393795256426,6 +Packing,35.0,16.902962006655393,10.974381412688764,6 +Packing,40.0,17.583203728745726,10.547091715076053,6 +Packing,45.0,18.375635358770833,10.106421962114458,6 +Packing,50.0,19.349977607939454,9.674895355913042,6 +Packing,55.0,20.627201587685292,9.281111730469375,6 +Packing,60.0,21.958792496224586,8.782067689905904,6 +Packing,65.0,23.875862987052017,8.355437428554781,6 +Packing,70.0,26.25477042384387,7.872246931609121,6 +Packing,75.0,29.939360614495243,7.4831532933187495,6 +Packing,80.0,35.21458970266888,7.036285443761063,6 +Packing,85.0,43.87634261951665,6.5792618136918195,6 +Packing,90.0,61.52894941327336,6.146753932210103,6 +Packing,95.0,99.38836807105238,5.736270380636558,6 +Packing,100.0,99.41603819726879,5.691936275795316,6 +Packing,105.0,99.45398521123286,5.655364735353471,6 +Packing,110.0,99.49825140157272,5.63738000053081,6 +Packing,115.0,99.55369222583008,5.604783126551739,6 +Packing,120.0,99.59940084996154,5.570800358229072,6 +Packing,5.0,13.920753649969578,13.2232145339641,7 +Packing,10.0,14.226993815652028,12.803263824425368,7 +Packing,15.0,14.559564681725092,12.37345026356904,7 +Packing,20.0,15.296820021706045,12.236766527730893,7 +Packing,25.0,15.68540513135917,11.762816590226668,7 +Packing,30.0,16.156444869223638,11.308783172049061,7 +Packing,35.0,16.77630392455472,10.90327424302063,7 +Packing,40.0,17.418354906257335,10.450760585103172,7 +Packing,45.0,18.10552196852834,9.93760570648337,7 +Packing,50.0,18.94264332428635,9.468851678065173,7 +Packing,55.0,20.264273016410996,9.117846358657435,7 +Packing,60.0,21.69473533942954,8.677649668374247,7 +Packing,65.0,23.665234784543244,8.280089262638299,7 +Packing,70.0,26.17464888927867,7.848897410090416,7 +Packing,75.0,29.70714356541083,7.424538248487977,7 +Packing,80.0,35.38136943687757,7.071204760073712,7 +Packing,85.0,44.09706584141582,6.614488889306641,7 +Packing,90.0,62.10497978948154,6.201000275986138,7 +Packing,95.0,99.4351020432961,5.818522149507091,7 +Packing,100.0,99.45720121299566,5.757054155210701,7 +Packing,105.0,99.50588521456125,5.723991149802192,7 +Packing,110.0,99.56613368773606,5.706139609493048,7 +Packing,115.0,99.6093530855181,5.694024674930357,7 +Packing,120.0,99.69157858959122,5.668714794784484,7 +Packing,5.0,14.02999465791878,13.326981709243574,8 +Packing,10.0,14.243211390305813,12.817652109911629,8 +Packing,15.0,14.547611728297294,12.363713576780293,8 +Packing,20.0,15.14346389205162,12.114283558461251,8 +Packing,25.0,15.508714365917903,11.631435911499816,8 +Packing,30.0,15.989917786001273,11.19155247022594,8 +Packing,35.0,16.67093154627751,10.832241026421904,8 +Packing,40.0,17.397995750596053,10.43602474981144,8 +Packing,45.0,18.087864002087766,9.946898437889919,8 +Packing,50.0,18.964801377038235,9.45959530115815,8 +Packing,55.0,19.99538553555723,8.997762549391505,8 +Packing,60.0,21.386014811409357,8.553855093531915,8 +Packing,65.0,23.34039821805151,8.16628382212523,8 +Packing,70.0,25.92543120715409,7.777337221099148,8 +Packing,75.0,29.406812273526683,7.336886049319191,8 +Packing,80.0,34.25044102253097,6.85003306857409,8 +Packing,85.0,42.30648884941004,6.341614642146916,8 +Packing,90.0,58.93324752573673,5.891901702488527,8 +Packing,95.0,99.3664278194136,5.504343444452391,8 +Packing,100.0,99.39655430804616,5.479771080791435,8 +Packing,105.0,99.43631843175632,5.438904101214101,8 +Packing,110.0,99.47495438807643,5.423883097357562,8 +Packing,115.0,99.54477158802337,5.415671443317483,8 +Packing,120.0,99.58561986271383,5.391602651678644,8 +Packing,5.0,14.006750815980265,13.305601551051543,9 +Packing,10.0,14.199208100161748,12.778190120170036,9 +Packing,15.0,14.485310354739553,12.311464479303956,9 +Packing,20.0,15.09715287181711,12.07594816326237,9 +Packing,25.0,15.541545301246476,11.655933808665516,9 +Packing,30.0,15.984036770481817,11.186432765384193,9 +Packing,35.0,16.55910466619458,10.76189860455584,9 +Packing,40.0,17.34706966217633,10.407599520096818,9 +Packing,45.0,18.15619302947286,9.9830418601623,9 +Packing,50.0,19.13050735699628,9.562174073321565,9 +Packing,55.0,20.23731364114801,9.102327983383267,9 +Packing,60.0,21.641717968722805,8.654701389156525,9 +Packing,65.0,23.628328643423597,8.26774693966595,9 +Packing,70.0,26.16669195266675,7.845921672858289,9 +Packing,75.0,29.9858973019654,7.496039887185306,9 +Packing,80.0,35.367493827872885,7.072075411830701,9 +Packing,85.0,43.26020340228583,6.486036001736471,9 +Packing,90.0,60.020384460301365,5.997400682903771,9 +Packing,95.0,99.42229365732317,5.558173557842092,9 +Packing,100.0,99.47034886494346,5.4881628090744705,9 +Packing,105.0,99.51669651335831,5.477102925137148,9 +Packing,110.0,99.57710879107047,5.429132481720468,9 +Packing,115.0,99.63140745632899,5.417497876786654,9 +Packing,120.0,99.67636752299576,5.3827163955672965,9 +Clustering,5.0,14.03192952767191,13.33008457861477,0 +Clustering,10.0,14.34555769773602,12.9104015021734,0 +Clustering,15.0,14.587611576829751,12.398413107335294,0 +Clustering,20.0,15.221782064565875,12.176151452252567,0 +Clustering,25.0,15.654703929404205,11.740700337344391,0 +Clustering,30.0,16.136344143884063,11.294999307269963,0 +Clustering,35.0,16.668475590777092,10.832845506370505,0 +Clustering,40.0,17.405604626867984,10.441093210804041,0 +Clustering,45.0,18.274289025126926,10.050682457486678,0 +Clustering,50.0,19.39439701628189,9.695575023522727,0 +Clustering,55.0,20.559210273928635,9.249361002036572,0 +Clustering,60.0,22.080425965026784,8.829788884820031,0 +Clustering,65.0,23.850420247282592,8.344114828559936,0 +Clustering,70.0,26.55501479709198,7.966376195334308,0 +Clustering,75.0,30.256126898394932,7.563739488987994,0 +Clustering,80.0,35.35607864588109,7.066093309539823,0 +Clustering,85.0,43.65540666464875,6.543602512500707,0 +Clustering,90.0,61.37153423672102,6.135869086992961,0 +Clustering,95.0,99.26933584510952,5.7260444977494425,0 +Clustering,100.0,99.27049765069033,5.694310435909592,0 +Clustering,105.0,99.27112646403017,5.681562072079289,0 +Clustering,110.0,99.27207455693569,5.648216682453841,0 +Clustering,115.0,99.27342984014484,5.62112624146369,0 +Clustering,120.0,99.27517205466937,5.578714916426895,0 +Clustering,5.0,13.976849758656003,13.277579775318483,1 +Clustering,10.0,14.256093390722349,12.829107094786885,1 +Clustering,15.0,14.63723836578718,12.441016414145311,1 +Clustering,20.0,15.314966097818738,12.251455147591662,1 +Clustering,25.0,15.754670880623872,11.814988693572818,1 +Clustering,30.0,16.268217728184855,11.386495367792905,1 +Clustering,35.0,16.79950081662514,10.919026483769017,1 +Clustering,40.0,17.444776828673596,10.464366765044241,1 +Clustering,45.0,18.184949879102497,10.00028801215405,1 +Clustering,50.0,19.043815941888198,9.502195843367437,1 +Clustering,55.0,20.190088757949383,9.084532386744502,1 +Clustering,60.0,21.558915627174866,8.621796281943709,1 +Clustering,65.0,23.309825052742028,8.15727552863899,1 +Clustering,70.0,25.68130267992192,7.703770682372914,1 +Clustering,75.0,29.09271540274352,7.272944685236732,1 +Clustering,80.0,34.471145255963464,6.889512297575894,1 +Clustering,85.0,42.46254363731205,6.367604298116817,1 +Clustering,90.0,59.66391375524144,5.9609167408106,1 +Clustering,95.0,99.26763674972705,5.598266449216321,1 +Clustering,100.0,99.26920556125111,5.578699237191351,1 +Clustering,105.0,99.26887888808969,5.535694194401652,1 +Clustering,110.0,99.26969935758319,5.512089085545893,1 +Clustering,115.0,99.27038128175295,5.460190578935812,1 +Clustering,120.0,99.27159259134925,5.395855318491466,1 +Clustering,5.0,13.996757771727832,13.296356587996087,2 +Clustering,10.0,14.28586125687072,12.855435355104216,2 +Clustering,15.0,14.598093499281214,12.40191702153599,2 +Clustering,20.0,15.340918229740197,12.27100589049517,2 +Clustering,25.0,15.732971890036545,11.798741174604496,2 +Clustering,30.0,16.231830269192805,11.361262126328567,2 +Clustering,35.0,16.85598628838626,10.954790148637478,2 +Clustering,40.0,17.541874483195073,10.523204458969127,2 +Clustering,45.0,18.350519528166572,10.09039296508632,2 +Clustering,50.0,19.373468891213566,9.686048327906212,2 +Clustering,55.0,20.65000798259791,9.290243127676455,2 +Clustering,60.0,22.197201580668946,8.877558519488316,2 +Clustering,65.0,24.30059814191801,8.504270498487466,2 +Clustering,70.0,26.924495603832217,8.077175310282936,2 +Clustering,75.0,30.983874529319515,7.745619490150707,2 +Clustering,80.0,36.625498591568316,7.322564469698991,2 +Clustering,85.0,45.347282439337036,6.800851374591045,2 +Clustering,90.0,63.59445586997404,6.3561696330568935,2 +Clustering,95.0,99.28508907514447,5.9302542579590325,2 +Clustering,100.0,99.28601478168191,5.898982990280597,2 +Clustering,105.0,99.28829706000991,5.861717653539592,2 +Clustering,110.0,99.2899302649324,5.841355105380248,2 +Clustering,115.0,99.28888808900723,5.771765997717532,2 +Clustering,120.0,99.28933120718891,5.732152744821967,2 +Clustering,5.0,14.000014147383608,13.298345698470795,3 +Clustering,10.0,14.259479997758175,12.833049948594166,3 +Clustering,15.0,14.595377028086961,12.404895701093158,3 +Clustering,20.0,15.148392904400376,12.11656838247782,3 +Clustering,25.0,15.51873454891328,11.638101600814299,3 +Clustering,30.0,15.995347612040414,11.19597085510512,3 +Clustering,35.0,16.62101061297454,10.80189098294658,3 +Clustering,40.0,17.437523177448995,10.459145421631527,3 +Clustering,45.0,18.211112305726186,10.015672027832956,3 +Clustering,50.0,19.080787489279,9.538397203772158,3 +Clustering,55.0,20.272389844495756,9.119866788108915,3 +Clustering,60.0,21.759649642211322,8.700392044079356,3 +Clustering,65.0,23.73514262175168,8.305122031055724,3 +Clustering,70.0,26.29985292299753,7.888728098832999,3 +Clustering,75.0,29.913068312376023,7.476581699164633,3 +Clustering,80.0,35.18631719943499,7.036980227417598,3 +Clustering,85.0,44.568014434797924,6.679319072522243,3 +Clustering,90.0,62.18158905908496,6.216156923002533,3 +Clustering,95.0,99.25180030245674,5.813707755321133,3 +Clustering,100.0,99.25277766726892,5.785804225510523,3 +Clustering,105.0,99.25420943023924,5.757127614601377,3 +Clustering,110.0,99.25408310757038,5.67099995450256,3 +Clustering,115.0,99.25587990426874,5.631157397723982,3 +Clustering,120.0,99.25685184887155,5.582958242838725,3 +Clustering,5.0,14.052327678123842,13.349575566648317,4 +Clustering,10.0,14.26474365631088,12.83787891617536,4 +Clustering,15.0,14.592356630900817,12.402751437276331,4 +Clustering,20.0,15.223850261217093,12.177609779135148,4 +Clustering,25.0,15.630377544092816,11.721977987301061,4 +Clustering,30.0,16.031093669211504,11.220888142200852,4 +Clustering,35.0,16.589633446162892,10.782781035881582,4 +Clustering,40.0,17.354961495161405,10.411049188881854,4 +Clustering,45.0,18.064031893921527,9.9250979616519,4 +Clustering,50.0,18.95351362577255,9.475475345448631,4 +Clustering,55.0,20.151200627967064,9.065218076444454,4 +Clustering,60.0,21.504634650487915,8.599880640338334,4 +Clustering,65.0,23.306546775567526,8.155265367704475,4 +Clustering,70.0,25.72511717067872,7.716872559647394,4 +Clustering,75.0,29.201009141028305,7.29813695136889,4 +Clustering,80.0,34.21716290762139,6.841008957622267,4 +Clustering,85.0,42.750422366105795,6.409191219217325,4 +Clustering,90.0,59.9653377032603,5.993348232424857,4 +Clustering,95.0,99.26116954608355,5.598860463176451,4 +Clustering,100.0,99.26206342389963,5.54202534728123,4 +Clustering,105.0,99.26392189752764,5.497227046231061,4 +Clustering,110.0,99.26448786681945,5.44963955925628,4 +Clustering,115.0,99.26488434921845,5.379351363058726,4 +Clustering,120.0,99.26749185485333,5.353924737773659,4 +Clustering,5.0,13.96346259079155,13.26463759323019,5 +Clustering,10.0,14.187767980874211,12.766821450078842,5 +Clustering,15.0,14.40290348927097,12.24096090096275,5 +Clustering,20.0,15.088729489121269,12.070279191497942,5 +Clustering,25.0,15.483204770022988,11.611705686767792,5 +Clustering,30.0,15.906911677542334,11.13325055592161,5 +Clustering,35.0,16.462942791987658,10.700488785357566,5 +Clustering,40.0,17.198011605126414,10.317311965286628,5 +Clustering,45.0,17.82219987355807,9.799340934984718,5 +Clustering,50.0,18.776639759286624,9.386173805234264,5 +Clustering,55.0,19.87267877460442,8.919480135000907,5 +Clustering,60.0,21.150300377901733,8.458043254310972,5 +Clustering,65.0,22.965938728299243,8.037967644060915,5 +Clustering,70.0,25.253527097428623,7.5744320167303645,5 +Clustering,75.0,28.62594332433298,7.152753214519704,5 +Clustering,80.0,33.506601342550354,6.699378482212048,5 +Clustering,85.0,41.93812406646739,6.289570915010145,5 +Clustering,90.0,59.2687560688107,5.919529028939505,5 +Clustering,95.0,99.27466150388986,5.513483293438816,5 +Clustering,100.0,99.27581869296706,5.479667210792736,5 +Clustering,105.0,99.27666970316547,5.457659804190427,5 +Clustering,110.0,99.27951958411059,5.415943914466086,5 +Clustering,115.0,99.2820584194836,5.37197126142253,5 +Clustering,120.0,99.28541141693603,5.354092075106135,5 +Clustering,5.0,14.019296169158304,13.318241088349012,6 +Clustering,10.0,14.2424199375798,12.810359744854157,6 +Clustering,15.0,14.499491501099419,12.322583782409724,6 +Clustering,20.0,15.283892138797011,12.226769257576645,6 +Clustering,25.0,15.672262197989657,11.754020045408868,6 +Clustering,30.0,16.060090512220164,11.239141931915533,6 +Clustering,35.0,16.715062655739455,10.852386276964246,6 +Clustering,40.0,17.503085990726504,10.4990339695179,6 +Clustering,45.0,18.249387434146374,10.036986822964995,6 +Clustering,50.0,19.180568269199256,9.59019150468205,6 +Clustering,55.0,20.3810956407197,9.17037752439634,6 +Clustering,60.0,21.718717066813472,8.686053363428973,6 +Clustering,65.0,23.590450136541673,8.255556255043361,6 +Clustering,70.0,25.879226941771687,7.759643736962879,6 +Clustering,75.0,29.430466500860476,7.355958437308603,6 +Clustering,80.0,34.45780245823914,6.885070532073436,6 +Clustering,85.0,42.66618614908963,6.397798734065599,6 +Clustering,90.0,59.70013715207867,5.964055234036855,6 +Clustering,95.0,99.29025454056338,5.555587036897766,6 +Clustering,100.0,99.29058404050464,5.513248736814418,6 +Clustering,105.0,99.29146893671782,5.474617035659227,6 +Clustering,110.0,99.29210623968821,5.4541927579151155,6 +Clustering,115.0,99.29453112108875,5.418680948172727,6 +Clustering,120.0,99.29614709740407,5.38232431594298,6 +Clustering,5.0,13.920711469429806,13.223174467000732,7 +Clustering,10.0,14.226992191866932,12.803262363136412,7 +Clustering,15.0,14.543439665942486,12.359746414233777,7 +Clustering,20.0,15.27738765911586,12.221221513554026,7 +Clustering,25.0,15.663228252491804,11.7461856803792,7 +Clustering,30.0,16.09752926776718,11.267544906594315,7 +Clustering,35.0,16.713008699869935,10.862137339676762,7 +Clustering,40.0,17.395900737736596,10.437288409308687,7 +Clustering,45.0,18.105890812141666,9.937808154245046,7 +Clustering,50.0,18.944102861175327,9.469581256196575,7 +Clustering,55.0,20.26201240321361,9.11682920280914,7 +Clustering,60.0,21.6912842799855,8.676269283484936,7 +Clustering,65.0,23.6602977731219,8.27836188086366,7 +Clustering,70.0,26.167009396344305,7.846606582940814,7 +Clustering,75.0,29.69524965508335,7.421565670799516,7 +Clustering,80.0,35.36395626968811,7.067724621439233,7 +Clustering,85.0,44.067333294709016,6.610029055163706,7 +Clustering,90.0,62.048803289692344,6.195391217068844,7 +Clustering,95.0,99.30597262737012,5.810966041540401,7 +Clustering,100.0,99.3064150160794,5.748325935525074,7 +Clustering,105.0,99.30926455387595,5.712680714050542,7 +Clustering,110.0,99.31067139864605,5.691499054190585,7 +Clustering,115.0,99.31293974053669,5.677080634556423,7 +Clustering,120.0,99.31558402136444,5.647334794569617,7 +Clustering,5.0,14.015602674379718,13.31331087713983,8 +Clustering,10.0,14.240483387433212,12.815197144467556,8 +Clustering,15.0,14.597422504691574,12.406046722858004,8 +Clustering,20.0,15.280374972357702,12.223808014751176,8 +Clustering,25.0,15.655648363477843,11.741635463539716,8 +Clustering,30.0,16.147614255919752,11.301926290847275,8 +Clustering,35.0,16.84021543725904,10.942236313962498,8 +Clustering,40.0,17.56031309404732,10.533389287535448,8 +Clustering,45.0,18.265112428710236,10.04437109124943,8 +Clustering,50.0,19.184720391026843,9.56929035305997,8 +Clustering,55.0,20.237690359987614,9.106797770088779,8 +Clustering,60.0,21.692309196377522,8.67636495841718,8 +Clustering,65.0,23.810325864395626,8.33070100558791,8 +Clustering,70.0,26.37555769554786,7.912370095361297,8 +Clustering,75.0,29.963157804624423,7.4756921098926785,8 +Clustering,80.0,35.121860848610595,7.024315630989272,8 +Clustering,85.0,43.67348925655449,6.546523866087135,8 +Clustering,90.0,60.94949442596928,6.093477706575688,8 +Clustering,95.0,99.27066446552372,5.6976759028553925,8 +Clustering,100.0,99.27183665331941,5.671534904742905,8 +Clustering,105.0,99.27211067224945,5.625046721752246,8 +Clustering,110.0,99.27368052707007,5.608036054500854,8 +Clustering,115.0,99.27569177600927,5.596163713651809,8 +Clustering,120.0,99.27619612676594,5.585964074724463,8 +Clustering,5.0,14.062748953970864,13.358796536918904,9 +Clustering,10.0,14.244430516272551,12.818886800342696,9 +Clustering,15.0,14.51741414753277,12.338750377565383,9 +Clustering,20.0,15.148665666038209,12.117152345139603,9 +Clustering,25.0,15.54153426896,11.655925534610494,9 +Clustering,30.0,15.983895266007437,11.18633373343679,9 +Clustering,35.0,16.547669331679522,10.754466686403195,9 +Clustering,40.0,17.346017666683274,10.406968361751234,9 +Clustering,45.0,18.0778004322678,9.939938298851038,9 +Clustering,50.0,19.046805462713884,9.520336600406745,9 +Clustering,55.0,20.20028165724154,9.085671757691996,9 +Clustering,60.0,21.60529626773795,8.640136050740942,9 +Clustering,65.0,23.660207600246235,8.278901649408128,9 +Clustering,70.0,26.297817614637438,7.8852388962575946,9 +Clustering,75.0,29.930149294120945,7.482103692906211,9 +Clustering,80.0,35.36013564596836,7.070604071577531,9 +Clustering,85.0,43.40164877674509,6.507243016934493,9 +Clustering,90.0,60.36257626870598,6.031593422651506,9 +Clustering,95.0,99.27161398242325,5.574200204959587,9 +Clustering,100.0,99.27979293336644,5.507215686881626,9 +Clustering,105.0,99.28134997972529,5.477735011598674,9 +Clustering,110.0,99.2816592390224,5.426608914684094,9 +Clustering,115.0,99.28346655549115,5.412163599434304,9 +Clustering,120.0,99.28331130065223,5.40704073504887,9 +FGD,5.0,13.938452456689154,13.241283016441582,0 +FGD,10.0,14.237714472471009,12.813347113156482,0 +FGD,15.0,14.466577054990129,12.295542531565376,0 +FGD,20.0,14.766409860322991,11.811891807587536,0 +FGD,25.0,15.122243296779361,11.341366005805934,0 +FGD,30.0,15.486334188788339,10.840010127127355,0 +FGD,35.0,15.872379930703012,10.315462783102962,0 +FGD,40.0,16.35724859995922,9.812216292724091,0 +FGD,45.0,16.970550260798095,9.333638729560064,0 +FGD,50.0,17.727201969652995,8.86211705935576,0 +FGD,55.0,18.664406515479243,8.396909776702348,0 +FGD,60.0,19.84145409030999,7.934441620953277,0 +FGD,65.0,21.33700311941029,7.464791072014165,0 +FGD,70.0,23.406850410675794,7.0219420830365555,0 +FGD,75.0,26.288847411183962,6.571957936047007,0 +FGD,80.0,30.340796809867328,6.063763560761473,0 +FGD,85.0,37.23339926635503,5.58099405326483,0 +FGD,90.0,50.92390885191275,5.091325188450966,0 +FGD,95.0,99.25960644362065,5.177094734020116,0 +FGD,100.0,99.26284678558103,5.145465114846236,0 +FGD,105.0,99.27365317826228,5.133240524370493,0 +FGD,110.0,99.2824358158883,5.10029151924761,0 +FGD,115.0,99.28927923055898,5.069954824844363,0 +FGD,120.0,99.29424563359144,5.027690280358938,0 +FGD,5.0,13.93967395276404,13.242263896778919,1 +FGD,10.0,14.152550460782834,12.735928458768223,1 +FGD,15.0,14.44844922939216,12.280553853790174,1 +FGD,20.0,14.730450870276849,11.783862725409701,1 +FGD,25.0,15.05361837364149,11.289244455158762,1 +FGD,30.0,15.498861154432166,10.848005214194899,1 +FGD,35.0,15.929339534644967,10.353455269076168,1 +FGD,40.0,16.353843297645433,9.809962945661486,1 +FGD,45.0,17.026717872769044,9.363351769533976,1 +FGD,50.0,17.666747812177803,8.815087172600121,1 +FGD,55.0,18.62135173591981,8.378679012162284,1 +FGD,60.0,19.644740088423063,7.8562832186523694,1 +FGD,65.0,21.060655701242727,7.370178496840716,1 +FGD,70.0,22.909346105868725,6.872250644072933,1 +FGD,75.0,25.773862329383334,6.44325813013777,1 +FGD,80.0,29.741926670613104,5.9443156886509465,1 +FGD,85.0,36.288942974187414,5.441822591464022,1 +FGD,90.0,49.77838609876238,4.97327105030181,1 +FGD,95.0,93.6282573064536,4.671163796589828,1 +FGD,100.0,99.33503738972512,4.802206226417942,1 +FGD,105.0,99.340060109845,4.759431534110104,1 +FGD,110.0,99.34337883780807,4.735922119933738,1 +FGD,115.0,99.34715305906686,4.68412550860753,1 +FGD,120.0,99.35082740741805,4.619845461189098,1 +FGD,5.0,13.949513420884122,13.251476356028707,2 +FGD,10.0,14.19574800613034,12.774345034492693,2 +FGD,15.0,14.47284414995412,12.295510521438406,2 +FGD,20.0,14.755145626997118,11.802453816160012,2 +FGD,25.0,15.071088132339888,11.302369910527998,2 +FGD,30.0,15.488483909750773,10.840966343276794,2 +FGD,35.0,15.945121956629386,10.362814844578832,2 +FGD,40.0,16.488477735536136,9.891281721028673,2 +FGD,45.0,17.099746050065406,9.402630643971815,2 +FGD,50.0,17.828526800872872,8.913631997362351,2 +FGD,55.0,18.649803478779113,8.390370054445196,2 +FGD,60.0,19.773622545156133,7.9082712588316575,2 +FGD,65.0,21.24702169975804,7.435636718352541,2 +FGD,70.0,23.244339553358454,6.973152192217751,2 +FGD,75.0,25.973220604917092,6.493012471666755,2 +FGD,80.0,30.24574459062987,6.047055281587984,2 +FGD,85.0,36.8258881567931,5.522875431988591,2 +FGD,90.0,50.1937097116517,5.016785332545119,2 +FGD,95.0,88.89186490672884,4.558641565250568,2 +FGD,100.0,99.34455791233142,4.766523742075064,2 +FGD,105.0,99.35323549403377,4.7455084519373285,2 +FGD,110.0,99.35675213956866,4.7252036839331435,2 +FGD,115.0,99.35750870746975,4.671658265176704,2 +FGD,120.0,99.3607483196497,4.664133002255276,2 +FGD,5.0,13.970249155641548,13.270072502048913,3 +FGD,10.0,14.219599441491706,12.797158796137978,3 +FGD,15.0,14.53699126320161,12.35527250037436,3 +FGD,20.0,14.837567023420151,11.867951709692234,3 +FGD,25.0,15.137182867637602,11.351961180108479,3 +FGD,30.0,15.577046003805323,10.903179930641649,3 +FGD,35.0,16.028212942242387,10.416635479337481,3 +FGD,40.0,16.653424639314032,9.988837766594347,3 +FGD,45.0,17.333712162497875,9.533123135474222,3 +FGD,50.0,18.03945399051955,9.01783941556019,3 +FGD,55.0,18.979073343702783,8.53804716582606,3 +FGD,60.0,20.20502220861183,8.078788830001955,3 +FGD,65.0,21.732891675979882,7.604517922353531,3 +FGD,70.0,23.791509560457946,7.136342189165629,3 +FGD,75.0,26.546045702925642,6.635015753484784,3 +FGD,80.0,30.96555818567422,6.192862397291104,3 +FGD,85.0,38.32369160160469,5.743494914240486,3 +FGD,90.0,52.371801314477395,5.235493982017127,3 +FGD,95.0,99.2902373543343,5.573487727858378,3 +FGD,100.0,99.29390468102255,5.53629053852525,3 +FGD,105.0,99.29973910490567,5.507842579843236,3 +FGD,110.0,99.30604202842008,5.4220267667062325,3 +FGD,115.0,99.312150583649,5.382392423856565,3 +FGD,120.0,99.31856503083549,5.3184675881370405,3 +FGD,5.0,13.96700603565115,13.26852083039754,4 +FGD,10.0,14.190767208051522,12.771302137210089,4 +FGD,15.0,14.464219518497496,12.293841492486244,4 +FGD,20.0,14.7936142503541,11.833462525758133,4 +FGD,25.0,15.167139087054746,11.374573007417933,4 +FGD,30.0,15.532059198571279,10.871591326294244,4 +FGD,35.0,15.955053704939306,10.370322591779951,4 +FGD,40.0,16.465689657047974,9.877584862183813,4 +FGD,45.0,17.097091028647498,9.393822171876586,4 +FGD,50.0,17.800871115205013,8.899232021564453,4 +FGD,55.0,18.81275514520051,8.463105060514675,4 +FGD,60.0,19.773967355854875,7.9077725248608095,4 +FGD,65.0,21.196062908670417,7.416779475540973,4 +FGD,70.0,23.07815754675237,6.922852849150068,4 +FGD,75.0,25.627778182140865,6.405088058062264,4 +FGD,80.0,29.588991763027515,5.915702545075601,4 +FGD,85.0,36.22687918921038,5.431174317080406,4 +FGD,90.0,49.44019482111681,4.941393071247061,4 +FGD,95.0,91.25135713562275,4.550375547311937,4 +FGD,100.0,99.33278890711357,4.615808571462861,4 +FGD,105.0,99.33856130065408,4.571140976785554,4 +FGD,110.0,99.342775472617,4.523678509005002,4 +FGD,115.0,99.34695711755543,4.495881613793799,4 +FGD,120.0,99.35776363152775,4.470779473645286,4 +FGD,5.0,14.004681196278401,13.303793344200008,5 +FGD,10.0,14.261626505099178,12.833282826710986,5 +FGD,15.0,14.502403426207138,12.325525436064376,5 +FGD,20.0,14.83109076702194,11.864180241382774,5 +FGD,25.0,15.19799984419559,11.397814847738386,5 +FGD,30.0,15.584561342081265,10.90763749386254,5 +FGD,35.0,16.013176776892465,10.408152459989068,5 +FGD,40.0,16.64377038197674,9.984815410769064,5 +FGD,45.0,17.243793299139643,9.481310430222369,5 +FGD,50.0,17.955263492857878,8.975579551148845,5 +FGD,55.0,18.896110391405188,8.481165683627244,5 +FGD,60.0,19.964492792952417,7.9838366631237045,5 +FGD,65.0,21.40788400665786,7.492656015897506,5 +FGD,70.0,23.39189082033448,7.016061007155054,5 +FGD,75.0,26.091690950367536,6.519520569261264,5 +FGD,80.0,30.390436209459814,6.07632604468729,5 +FGD,85.0,37.2248549154568,5.5827095275091745,5 +FGD,90.0,51.49141237114385,5.142758689219049,5 +FGD,95.0,97.58634718345893,4.994309642074237,5 +FGD,100.0,99.34346369798739,4.991961074263791,5 +FGD,105.0,99.34752903950651,4.9700952349657666,5 +FGD,110.0,99.35476752986455,4.928553060902715,5 +FGD,115.0,99.3599120878302,4.884662516500702,5 +FGD,120.0,99.37116933653992,4.867139726712096,5 +FGD,5.0,13.936763173620395,13.239835274030334,6 +FGD,10.0,14.172952013961304,12.747876747148625,6 +FGD,15.0,14.432423618071628,12.26558525886453,6 +FGD,20.0,14.712321594351236,11.76952570351975,6 +FGD,25.0,15.038041519669173,11.278361683392193,6 +FGD,30.0,15.402772638516371,10.779138990380405,6 +FGD,35.0,15.886471350144808,10.314416835912837,6 +FGD,40.0,16.407120449213767,9.841631071774042,6 +FGD,45.0,17.049893827988885,9.3772769251573,6 +FGD,50.0,17.83087660588467,8.91535219117508,6 +FGD,55.0,18.711994843460783,8.419373520148664,6 +FGD,60.0,19.75414443625039,7.900353975527382,6 +FGD,65.0,21.22080850697279,7.426292308659564,6 +FGD,70.0,23.139495646571635,6.9381609765390815,6 +FGD,75.0,25.709262555230477,6.425867113068027,6 +FGD,80.0,29.770714314950546,5.948535693680947,6 +FGD,85.0,36.26887469252532,5.438521263255052,6 +FGD,90.0,49.53937148321561,4.948992780916596,6 +FGD,95.0,89.80840620158254,4.488540868223638,6 +FGD,100.0,99.33223157815506,4.652240736533858,6 +FGD,105.0,99.33609707271881,4.610205535425744,6 +FGD,110.0,99.33977837572796,4.589907145750374,6 +FGD,115.0,99.34331349689904,4.570400123032624,6 +FGD,120.0,99.34974505938466,4.534231523146494,6 +FGD,5.0,13.916357955424463,13.219039098247226,7 +FGD,10.0,14.201951385050457,12.780727450968577,7 +FGD,15.0,14.451613146889276,12.281707620408586,7 +FGD,20.0,14.805130517360855,11.843437086692147,7 +FGD,25.0,15.16380718812341,11.371659276230647,7 +FGD,30.0,15.568460810518228,10.897220833778256,7 +FGD,35.0,15.98303748308741,10.38771362859685,7 +FGD,40.0,16.514443647175696,9.908426925599647,7 +FGD,45.0,17.153316346897558,9.41496714153549,7 +FGD,50.0,17.851889919419058,8.923617202009154,7 +FGD,55.0,18.79230485529651,8.455538881502516,7 +FGD,60.0,19.91220875636341,7.964659121570966,7 +FGD,65.0,21.380432630364318,7.480673327985227,7 +FGD,70.0,23.44711205014068,7.031000790991718,7 +FGD,75.0,26.151591529598956,6.535919252647819,7 +FGD,80.0,30.244320405548624,6.044530944412855,7 +FGD,85.0,36.98719594871367,5.54801985078105,7 +FGD,90.0,50.46075057581878,5.038358104419116,7 +FGD,95.0,98.98735310066023,4.967214698734339,7 +FGD,100.0,99.3186992146443,4.894467706146,7 +FGD,105.0,99.32306770911741,4.8588678438705095,7 +FGD,110.0,99.32760885325833,4.837823782138081,7 +FGD,115.0,99.33266811730785,4.823518888857989,7 +FGD,120.0,99.33868906547183,4.793907309730692,7 +FGD,5.0,13.943634274841015,13.244948659784708,8 +FGD,10.0,14.218429046578008,12.795350154849189,8 +FGD,15.0,14.510738356326671,12.332375662477277,8 +FGD,20.0,14.843780245208574,11.874546289526638,8 +FGD,25.0,15.178125680834793,11.383496526397629,8 +FGD,30.0,15.522881318483453,10.864667541754903,8 +FGD,35.0,15.991993731348986,10.391088830886638,8 +FGD,40.0,16.548567659189914,9.926503267442055,8 +FGD,45.0,17.088983241384447,9.397592810805833,8 +FGD,50.0,17.839211241158022,8.898153768040142,8 +FGD,55.0,18.689627434513504,8.410181913887206,8 +FGD,60.0,19.758289138476467,7.902806749038019,8 +FGD,65.0,21.47218776513311,7.512638727664343,8 +FGD,70.0,23.455054713845634,7.036252110575136,8 +FGD,75.0,26.204682379483106,6.537967012152198,8 +FGD,80.0,30.221526731285564,6.044256696020903,8 +FGD,85.0,36.892484443622934,5.530071766665145,8 +FGD,90.0,50.46237006892383,5.04501850149792,8 +FGD,95.0,91.54557812495095,4.739532096066541,8 +FGD,100.0,99.26899778386738,4.897291864269779,8 +FGD,105.0,99.27153619046342,4.854429257658879,8 +FGD,110.0,99.2824377786705,4.837861222730754,8 +FGD,115.0,99.28876190921923,4.826181851012336,8 +FGD,120.0,99.2919620121688,4.8001238106687545,8 +FGD,5.0,13.928054669713235,13.230844772724495,9 +FGD,10.0,14.149236789350716,12.733219801713311,9 +FGD,15.0,14.381672415590078,12.223379738604589,9 +FGD,20.0,14.671249479929308,11.735275499571205,9 +FGD,25.0,14.987260979299336,11.24022859772496,9 +FGD,30.0,15.367507305914033,10.754954440959768,9 +FGD,35.0,15.759523673788852,10.242244327355214,9 +FGD,40.0,16.271908545061038,9.762542657789142,9 +FGD,45.0,16.85756249248699,9.268999935703222,9 +FGD,50.0,17.57272001061935,8.783531170794122,9 +FGD,55.0,18.436972313711625,8.292571434913022,9 +FGD,60.0,19.511258668355012,7.802713155455179,9 +FGD,65.0,21.062350365122395,7.369889991007887,9 +FGD,70.0,23.071293804669367,6.9177855729863635,9 +FGD,75.0,25.938550160874502,6.484261740232392,9 +FGD,80.0,30.39895983478882,6.078568570312769,9 +FGD,85.0,36.708144664075554,5.503680730164203,9 +FGD,90.0,50.087372418569565,5.004867000588291,9 +FGD,95.0,91.18045762388694,4.606873539895857,9 +FGD,100.0,99.28822056337866,4.717309307320585,9 +FGD,105.0,99.29179111443054,4.703892660506384,9 +FGD,110.0,99.2959734774638,4.668924805703848,9 +FGD,115.0,99.2995987495233,4.654548802943673,9 +FGD,120.0,99.30094028624949,4.64949637663529,9 diff --git a/standalone_fgd_replication/result/fig7-runs10-seed42/figure7a.png b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7a.png new file mode 100644 index 0000000..60fb7fc Binary files /dev/null and b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7a.png differ diff --git a/standalone_fgd_replication/result/fig7-runs10-seed42/figure7b.png b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7b.png new file mode 100644 index 0000000..3a30c49 Binary files /dev/null and b/standalone_fgd_replication/result/fig7-runs10-seed42/figure7b.png differ diff --git a/standalone_fgd_replication/result/fig7-runs10-seed42/paper-figure7.png b/standalone_fgd_replication/result/fig7-runs10-seed42/paper-figure7.png new file mode 100644 index 0000000..62e7b56 Binary files /dev/null and b/standalone_fgd_replication/result/fig7-runs10-seed42/paper-figure7.png differ diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/experiment_summary.log b/standalone_fgd_replication/result/fig9-runs10-seed42/experiment_summary.log new file mode 100644 index 0000000..5aca985 --- /dev/null +++ b/standalone_fgd_replication/result/fig9-runs10-seed42/experiment_summary.log @@ -0,0 +1,23 @@ +Experiment: Figure 9 Replication - Monte-Carlo +Result: fig9-runs10-seed42 +Runs: 10 +Base seed: 42 +Sample interval: 2.0% +Max arrival: 120.0% +Nodes: 1213 +GPUs: 6212 +Task pool: 8152 + +====================================================================== +EXPERIMENT SUMMARY (Figure 9) +====================================================================== + +Scheduler Scheduled Failed Unalloc% Occupied Deficient Stranded Non-GPU +-------------------------------------------------------------------------------- +Random 7990 2000 12.1 1213 34.5 52.1 13.4 +BestFit 8089 1901 6.8 1213 61.3 25.3 13.4 +BestFit-PN 8143 1848 6.1 1213 69.2 17.4 13.4 +DotProd 7854 2137 10.1 1213 40.2 46.4 13.4 +Packing 8185 1805 5.5 1213 72.5 14.1 13.4 +Clustering 8184 1806 5.5 1213 72.7 13.9 13.4 +FGD 8241 1750 4.8 1213 77.4 9.1 13.4 diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/figure9.png b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9.png new file mode 100644 index 0000000..78b0300 Binary files /dev/null and b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9.png differ diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/figure9a_unalloc.csv b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9a_unalloc.csv new file mode 100644 index 0000000..cd1a032 --- /dev/null +++ b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9a_unalloc.csv @@ -0,0 +1,4201 @@ +scheduler,arrived_pct,unalloc_gpu_pct,run +Random,2.0,97.99822923374113,0 +Random,4.0,95.98599484867992,0 +Random,6.0,93.98502897617512,0 +Random,8.0,91.98535093367671,0 +Random,10.0,89.99581455247905,0 +Random,12.0,87.99549259497745,0 +Random,14.0,85.994204764971,0 +Random,16.0,83.97198969735992,0 +Random,18.0,81.98840952994203,0 +Random,20.0,79.99162910495812,0 +Random,22.0,77.99259497746296,0 +Random,24.0,75.99388280746939,0 +Random,26.0,73.9927559562138,0 +Random,28.0,71.9877656149389,0 +Random,30.0,69.99726336123646,0 +Random,32.0,67.9798776561496,0 +Random,34.0,65.99710238248578,0 +Random,36.0,63.94687701223464,0 +Random,38.0,62.09449452672271,0 +Random,40.0,60.11574372182895,0 +Random,42.0,58.1245975531232,0 +Random,44.0,56.120734063103875,0 +Random,46.0,54.12508048937561,0 +Random,48.0,52.11944623309738,0 +Random,50.0,50.12041210560222,0 +Random,52.0,48.06761107533822,0 +Random,54.0,46.118641339343384,0 +Random,56.0,44.112846104314386,0 +Random,58.0,42.24629748873166,0 +Random,60.0,40.24678042498406,0 +Random,62.0,38.50949774629764,0 +Random,64.0,36.50386349001944,0 +Random,66.0,34.51078557630407,0 +Random,68.0,32.63924661944637,0 +Random,70.0,30.643432066967275,0 +Random,72.0,28.639568576947923,0 +Random,74.0,26.73502897617521,0 +Random,76.0,24.888763683193886,0 +Random,78.0,22.892144236960778,0 +Random,80.0,21.015775917578935,0 +Random,82.0,19.021571152607912,0 +Random,84.0,17.088538312942738,0 +Random,86.0,15.156149388280793,0 +Random,88.0,13.836928525434686,0 +Random,90.0,13.154861558274341,0 +Random,92.0,12.90325177076628,0 +Random,94.0,12.679008370895065,0 +Random,96.0,12.60849967804252,0 +Random,98.0,12.528493238892485,0 +Random,100.0,12.408242112041227,0 +Random,102.0,12.391017385705105,0 +Random,104.0,12.306342562781728,0 +Random,106.0,12.248551191242768,0 +Random,108.0,12.185769478428861,0 +Random,110.0,12.123953638119785,0 +Random,112.0,12.058113329040586,0 +Random,114.0,11.981648422408261,0 +Random,116.0,11.88667095943337,0 +Random,118.0,11.87411461687059,0 +Random,120.0,11.851416613007098,0 +Random,2.0,97.98921442369604,1 +Random,4.0,95.99291693496458,1 +Random,6.0,93.986799742434,1 +Random,8.0,91.97488731487444,1 +Random,10.0,89.99034127495172,1 +Random,12.0,87.99758531873789,1 +Random,14.0,85.99597553122986,1 +Random,16.0,83.98824855119113,1 +Random,18.0,81.9898583386992,1 +Random,20.0,79.99661944623304,1 +Random,22.0,77.98728267868643,1 +Random,24.0,75.99597553122989,1 +Random,26.0,73.99597553122992,1 +Random,28.0,71.98824855119132,1 +Random,30.0,69.99227301996149,1 +Random,32.0,67.99001931745026,1 +Random,34.0,65.99855119124297,1 +Random,36.0,63.99806825499059,1 +Random,38.0,61.98438506117219,1 +Random,40.0,59.985672891178574,1 +Random,42.0,57.99001931745029,1 +Random,44.0,55.98953638119788,1 +Random,46.0,53.99758531873813,1 +Random,48.0,51.99581455247924,1 +Random,50.0,49.8964906632326,1 +Random,52.0,48.12749517063759,1 +Random,54.0,46.376207340631154,1 +Random,56.0,44.37636831938194,1 +Random,58.0,42.383612363168155,1 +Random,60.0,40.50692208628471,1 +Random,62.0,38.5106245975532,1 +Random,64.0,36.51448808757252,1 +Random,66.0,34.64294913071483,1 +Random,68.0,32.63506117192541,1 +Random,70.0,30.77028332260152,1 +Random,72.0,29.018190598841038,1 +Random,74.0,27.286703155183613,1 +Random,76.0,25.41097875080498,1 +Random,78.0,23.41033483580176,1 +Random,80.0,21.789278815196468,1 +Random,82.0,20.0539278815197,1 +Random,84.0,18.177076625885423,1 +Random,86.0,16.182710882163583,1 +Random,88.0,14.719575016097897,1 +Random,90.0,13.950901481004543,1 +Random,92.0,13.349323889246659,1 +Random,94.0,13.146651641983295,1 +Random,96.0,12.945589182227973,1 +Random,98.0,12.816967160334864,1 +Random,100.0,12.697359948486827,1 +Random,102.0,12.576303927881542,1 +Random,104.0,12.483741146168729,1 +Random,106.0,12.425466838377359,1 +Random,108.0,12.35383129426918,1 +Random,110.0,12.25627817128141,1 +Random,112.0,12.18222794591116,1 +Random,114.0,12.131358660656815,1 +Random,116.0,12.036381197681925,1 +Random,118.0,12.010302640051531,1 +Random,120.0,11.97762395363814,1 +Random,2.0,97.93206696716032,2 +Random,4.0,95.99517063747582,2 +Random,6.0,93.98889246619444,2 +Random,8.0,91.98712169993549,2 +Random,10.0,89.98712169993553,2 +Random,12.0,87.99951706374752,2 +Random,14.0,85.99565357372818,2 +Random,16.0,83.98712169993553,2 +Random,18.0,81.99629748873139,2 +Random,20.0,79.98873148744352,2 +Random,22.0,77.99356084996771,2 +Random,24.0,75.99726336123621,2 +Random,26.0,73.99710238248538,2 +Random,28.0,71.9993560849967,2 +Random,30.0,69.99372182871856,2 +Random,32.0,67.98857050869287,2 +Random,34.0,65.99420476497113,2 +Random,36.0,63.98309723116559,2 +Random,38.0,61.997585318738025,2 +Random,40.0,59.9890534449454,2 +Random,42.0,57.99195106245991,2 +Random,44.0,55.99661944623327,2 +Random,46.0,53.99243399871233,2 +Random,48.0,51.987282678686576,2 +Random,50.0,49.996458467482455,2 +Random,52.0,47.995331616226814,2 +Random,54.0,46.11944623309735,2 +Random,56.0,44.24839021249209,2 +Random,58.0,42.25305859626538,2 +Random,60.0,40.509175788795986,2 +Random,62.0,38.63892466194474,2 +Random,64.0,36.76722472633622,2 +Random,66.0,35.02398583387003,2 +Random,68.0,33.0238248551192,2 +Random,70.0,31.1584030907921,2 +Random,72.0,29.27962009014817,2 +Random,74.0,27.28638119768198,2 +Random,76.0,25.54459111397301,2 +Random,78.0,23.540727623953693,2 +Random,80.0,21.796039922730255,2 +Random,82.0,19.787025112685182,2 +Random,84.0,17.92353509336771,2 +Random,86.0,15.927237604636229,2 +Random,88.0,14.95991629104963,2 +Random,90.0,14.163393432067013,2 +Random,92.0,13.963135866065723,2 +Random,94.0,13.72858982614299,2 +Random,96.0,13.614133934320707,2 +Random,98.0,13.486155827430812,2 +Random,100.0,13.377334191886705,2 +Random,102.0,13.321474565357407,2 +Random,104.0,13.229233741146205,2 +Random,106.0,13.127978106889932,2 +Random,108.0,13.101094655505516,2 +Random,110.0,13.033966516419875,2 +Random,112.0,12.985028976175187,2 +Random,114.0,12.906310367031598,2 +Random,116.0,12.775595621378018,2 +Random,118.0,12.760946555054772,2 +Random,120.0,12.749517063747628,2 +Random,2.0,97.99694140373462,3 +Random,4.0,95.99388280746932,3 +Random,6.0,93.99919510624592,3 +Random,8.0,91.996619446233,3 +Random,10.0,89.99661944623298,3 +Random,12.0,87.99146812620725,3 +Random,14.0,85.989214423696,3 +Random,16.0,83.98470701867349,3 +Random,18.0,81.98486799742432,3 +Random,20.0,79.98583386992915,3 +Random,22.0,77.9906632324533,3 +Random,24.0,75.99871216999357,3 +Random,26.0,73.99146812620735,3 +Random,28.0,71.99291693496464,3 +Random,30.0,69.99517063747601,3 +Random,32.0,67.99903412749536,3 +Random,34.0,65.98551191242778,3 +Random,36.0,63.99597553123011,3 +Random,38.0,61.98776561493907,3 +Random,40.0,59.980682549903634,3 +Random,42.0,57.99629748873172,3 +Random,44.0,55.99050225370274,3 +Random,46.0,54.119446233097456,3 +Random,48.0,52.2562781712816,3 +Random,50.0,50.24710238248574,3 +Random,52.0,48.2430779137156,3 +Random,54.0,46.24291693496481,3 +Random,56.0,44.255473277527585,3 +Random,58.0,42.24388280746963,3 +Random,60.0,40.37041210560226,3 +Random,62.0,38.631680618158626,3 +Random,64.0,36.757083065035594,3 +Random,66.0,34.87540244687719,3 +Random,68.0,33.028171281390996,3 +Random,70.0,31.154378622022033,3 +Random,72.0,29.40453960077286,3 +Random,74.0,27.535093367675636,3 +Random,76.0,25.543947198969867,3 +Random,78.0,23.543464262717432,3 +Random,80.0,21.54459111397306,3 +Random,82.0,19.53783000643924,3 +Random,84.0,17.544591113973038,3 +Random,86.0,15.717643271088289,3 +Random,88.0,15.166934964584744,3 +Random,90.0,14.327108821635603,3 +Random,92.0,13.850289761751513,3 +Random,94.0,13.517868641339406,3 +Random,96.0,13.410334835801729,3 +Random,98.0,13.29958145524796,3 +Random,100.0,13.20717965228595,3 +Random,102.0,13.093850611719304,3 +Random,104.0,13.036542176432759,3 +Random,106.0,12.910334835801718,3 +Random,108.0,12.871860914359345,3 +Random,110.0,12.799259497746332,3 +Random,112.0,12.734063103670351,3 +Random,114.0,12.654861558274344,3 +Random,116.0,12.558918222794627,3 +Random,118.0,12.521088216355473,3 +Random,120.0,12.477945911139766,3 +Random,2.0,97.9966194462331,4 +Random,4.0,95.99629748873146,4 +Random,6.0,93.99983902124913,4 +Random,8.0,91.99710238248542,4 +Random,10.0,89.99726336123621,4 +Random,12.0,87.98792659368956,4 +Random,14.0,85.99323889246617,4 +Random,16.0,83.99227301996136,4 +Random,18.0,81.99533161622668,4 +Random,20.0,79.9903412749517,4 +Random,22.0,77.99565357372828,4 +Random,24.0,75.99420476497104,4 +Random,26.0,73.93947198969741,4 +Random,28.0,71.9971023824856,4 +Random,30.0,69.99452672247271,4 +Random,32.0,67.90534449452686,4 +Random,34.0,65.99710238248568,4 +Random,36.0,63.98358016741808,4 +Random,38.0,61.995170637476015,4 +Random,40.0,59.988892466194585,4 +Random,42.0,57.997102382485636,4 +Random,44.0,55.99629748873161,4 +Random,46.0,53.99887314874449,4 +Random,48.0,51.99871216999368,4 +Random,50.0,49.9932388924663,4 +Random,52.0,47.994526722472735,4 +Random,54.0,46.12234385061185,4 +Random,56.0,44.123631680618274,4 +Random,58.0,42.247102382485636,4 +Random,60.0,40.24839021249208,4 +Random,62.0,38.50627817128153,4 +Random,64.0,36.638763683193936,4 +Random,66.0,34.635383129427034,4 +Random,68.0,33.019156471345894,4 +Random,70.0,31.027688345138554,4 +Random,72.0,29.020444301352317,4 +Random,74.0,27.029620090148203,4 +Random,76.0,25.02559562137806,4 +Random,78.0,23.155988409530014,4 +Random,80.0,21.151963940759885,4 +Random,82.0,19.28783000643921,4 +Random,84.0,17.531229877656195,4 +Random,86.0,15.536059240180327,4 +Random,88.0,14.190115904700606,4 +Random,90.0,13.294752092723785,4 +Random,92.0,12.79958145524793,4 +Random,94.0,12.507405022537046,4 +Random,96.0,12.346748229233768,4 +Random,98.0,12.20991629104961,4 +Random,100.0,12.089182227945937,4 +Random,102.0,11.996297488731518,4 +Random,104.0,11.870573084352902,4 +Random,106.0,11.80376690276887,4 +Random,108.0,11.732775273663911,4 +Random,110.0,11.66806181584034,4 +Random,112.0,11.627173213135897,4 +Random,114.0,11.50450740502257,4 +Random,116.0,11.431101094655533,4 +Random,118.0,11.401481004507433,4 +Random,120.0,11.342723760463649,4 +Random,2.0,97.98164842240823,5 +Random,4.0,95.98905344494528,5 +Random,6.0,93.99098518995494,5 +Random,8.0,91.99581455247908,5 +Random,10.0,89.98470701867348,5 +Random,12.0,87.99919510624589,5 +Random,14.0,85.996619446233,5 +Random,16.0,83.99887314874435,5 +Random,18.0,81.99034127495169,5 +Random,20.0,79.9953316162267,5 +Random,22.0,77.99436574372187,5 +Random,24.0,75.99468770122346,5 +Random,26.0,73.99565357372829,5 +Random,28.0,71.9998390212493,5 +Random,30.0,69.99001931745022,5 +Random,32.0,67.99468770122361,5 +Random,34.0,65.9903412749519,5 +Random,36.0,63.994687701223654,5 +Random,38.0,61.99339987121719,5 +Random,40.0,59.99130714745669,5 +Random,42.0,57.99098518995505,5 +Random,44.0,55.993560849967906,5 +Random,46.0,53.99468770122352,5 +Random,48.0,51.92289117836454,5 +Random,50.0,49.98857050869295,5 +Random,52.0,47.999839021249294,5 +Random,54.0,46.05183515775927,5 +Random,56.0,44.12685125563435,5 +Random,58.0,42.12669027688356,5 +Random,60.0,40.1189632968449,5 +Random,62.0,38.197681905988524,5 +Random,64.0,36.503058596265376,5 +Random,66.0,34.63715389568586,5 +Random,68.0,32.89552479072773,5 +Random,70.0,31.02382485511921,5 +Random,72.0,29.027688345138525,5 +Random,74.0,27.151320025756693,5 +Random,76.0,25.27768834513853,5 +Random,78.0,23.331777205408976,5 +Random,80.0,21.66838377334203,5 +Random,82.0,19.80280103026408,5 +Random,84.0,17.79443013522222,5 +Random,86.0,15.916291049581513,5 +Random,88.0,14.373792659369004,5 +Random,90.0,13.679491307147485,5 +Random,92.0,13.482292337411486,5 +Random,94.0,13.220540888602722,5 +Random,96.0,13.053766902768855,5 +Random,98.0,12.98486799742436,5 +Random,100.0,12.935125563425645,5 +Random,102.0,12.823889246619466,5 +Random,104.0,12.755151320025776,5 +Random,106.0,12.669349645846767,5 +Random,108.0,12.577913715389593,5 +Random,110.0,12.482131358660682,5 +Random,112.0,12.373792659368986,5 +Random,114.0,12.295878943979416,5 +Random,116.0,12.233258209916315,5 +Random,118.0,12.166291049581476,5 +Random,120.0,12.134900193174527,5 +Random,2.0,97.98824855119122,6 +Random,4.0,95.98551191242754,6 +Random,6.0,93.99227301996133,6 +Random,8.0,91.99645846748223,6 +Random,10.0,89.94510624597544,6 +Random,12.0,87.99388280746935,6 +Random,14.0,85.99372182871849,6 +Random,16.0,83.9956535737282,6 +Random,18.0,81.98599484867994,6 +Random,20.0,79.99774629748872,6 +Random,22.0,77.98889246619449,6 +Random,24.0,75.99356084996784,6 +Random,26.0,73.99597553122999,6 +Random,28.0,71.98422408242128,6 +Random,30.0,69.98180940115925,6 +Random,32.0,67.99227301996154,6 +Random,34.0,65.99339987121715,6 +Random,36.0,63.99517063747605,6 +Random,38.0,61.99500965872525,6 +Random,40.0,59.98390212491973,6 +Random,42.0,57.99452672247285,6 +Random,44.0,55.996458467482505,6 +Random,46.0,53.987926593689814,6 +Random,48.0,51.998390212492104,6 +Random,50.0,50.257083065035545,6 +Random,52.0,48.24678042498407,6 +Random,54.0,46.254829362524276,6 +Random,56.0,44.25144880875733,6 +Random,58.0,42.25676110753391,6 +Random,60.0,40.37974887314879,6 +Random,62.0,38.38184159690928,6 +Random,64.0,36.75740502253711,6 +Random,66.0,34.75981970379915,6 +Random,68.0,32.88860270444308,6 +Random,70.0,31.143110109465617,6 +Random,72.0,29.15212491951069,6 +Random,74.0,27.282034771410252,6 +Random,76.0,25.410334835801745,6 +Random,78.0,23.415325177076706,6 +Random,80.0,21.526561493882884,6 +Random,82.0,19.541854475209327,6 +Random,84.0,17.670959433354835,6 +Random,86.0,15.799098518995525,6 +Random,88.0,14.6865743721829,6 +Random,90.0,13.740824211204133,6 +Random,92.0,13.394236960721203,6 +Random,94.0,13.184964584674844,6 +Random,96.0,13.067933032839688,6 +Random,98.0,12.995170637475875,6 +Random,100.0,12.920154539600793,6 +Random,102.0,12.812459755312315,6 +Random,104.0,12.765292981326478,6 +Random,106.0,12.696394075981987,6 +Random,108.0,12.607694784288487,6 +Random,110.0,12.535898261429503,6 +Random,112.0,12.413554410817783,6 +Random,114.0,12.337572440437869,6 +Random,116.0,12.308757244043791,6 +Random,118.0,12.283000643915008,6 +Random,120.0,12.255151320025764,6 +Random,2.0,97.99533161622664,7 +Random,4.0,95.99372182871855,7 +Random,6.0,93.99951706374758,7 +Random,8.0,91.99195106245972,7 +Random,10.0,89.99275595621371,7 +Random,12.0,87.9980682549903,7 +Random,14.0,85.98760463618798,7 +Random,16.0,83.99388280746938,7 +Random,18.0,81.98518995492594,7 +Random,20.0,79.99549259497746,7 +Random,22.0,77.9961365099807,7 +Random,24.0,75.98969735994848,7 +Random,26.0,73.98857050869286,7 +Random,28.0,71.98567289117845,7 +Random,30.0,69.99549259497756,7 +Random,32.0,67.99661944623324,7 +Random,34.0,65.9961365099809,7 +Random,36.0,63.97794591113991,7 +Random,38.0,61.98921442369626,7 +Random,40.0,59.99855119124295,7 +Random,42.0,57.993560849967984,7 +Random,44.0,55.98615582743094,7 +Random,46.0,53.96522858982632,7 +Random,48.0,51.94993560849986,7 +Random,50.0,49.98696072118495,7 +Random,52.0,48.11332904056681,7 +Random,54.0,46.23068254990358,7 +Random,56.0,44.384095299420636,7 +Random,58.0,42.5053122987767,7 +Random,60.0,40.64278815196406,7 +Random,62.0,38.77205408886038,7 +Random,64.0,36.899710238248666,7 +Random,66.0,34.895685769478575,7 +Random,68.0,33.01996136509992,7 +Random,70.0,31.016902768834626,7 +Random,72.0,29.022215067611196,7 +Random,74.0,27.15518351577602,7 +Random,76.0,25.158886027044534,7 +Random,78.0,23.151641983258315,7 +Random,80.0,21.273502897617604,7 +Random,82.0,19.27189311010955,7 +Random,84.0,17.53010302640059,7 +Random,86.0,15.80054732775279,7 +Random,88.0,14.72424339987127,7 +Random,90.0,13.896490663232491,7 +Random,92.0,13.205730843528684,7 +Random,94.0,13.0156149388281,7 +Random,96.0,12.885866065679352,7 +Random,98.0,12.750321957501626,7 +Random,100.0,12.654861558274325,7 +Random,102.0,12.595943335479731,7 +Random,104.0,12.509658725048311,7 +Random,106.0,12.455569864777866,7 +Random,108.0,12.375724404378637,7 +Random,110.0,12.280585962652946,7 +Random,112.0,12.220540888602718,7 +Random,114.0,12.120090148100457,7 +Random,116.0,12.077591757887967,7 +Random,118.0,12.030103026400527,7 +Random,120.0,12.001126851255648,7 +Random,2.0,97.98760463618802,8 +Random,4.0,95.98792659368962,8 +Random,6.0,93.98969735994847,8 +Random,8.0,91.995009658725,8 +Random,10.0,89.99130714745654,8 +Random,12.0,87.98502897617513,8 +Random,14.0,85.99339987121701,8 +Random,16.0,83.99597553122987,8 +Random,18.0,81.99855119124278,8 +Random,20.0,79.99678042498394,8 +Random,22.0,77.99629748873151,8 +Random,24.0,75.99050225370254,8 +Random,26.0,73.99758531873798,8 +Random,28.0,71.91870573084363,8 +Random,30.0,69.99130714745667,8 +Random,32.0,67.99066323245351,8 +Random,34.0,65.99839021249215,8 +Random,36.0,63.99356084996798,8 +Random,38.0,61.985511912427725,8 +Random,40.0,59.98406310367048,8 +Random,42.0,57.98824855119145,8 +Random,44.0,55.999517063747795,8 +Random,46.0,53.92627173213157,8 +Random,48.0,51.988731487443864,8 +Random,50.0,49.87974887314897,8 +Random,52.0,47.9937218287188,8 +Random,54.0,46.11622665808131,8 +Random,56.0,44.11461687057325,8 +Random,58.0,42.12636831938201,8 +Random,60.0,40.12620734063118,8 +Random,62.0,38.1281390856408,8 +Random,64.0,36.12701223438515,8 +Random,66.0,34.113168061815934,8 +Random,68.0,32.24806825499045,8 +Random,70.0,30.385222150676235,8 +Random,72.0,28.50820991629116,8 +Random,74.0,27.02350289761761,8 +Random,76.0,25.285737282678767,8 +Random,78.0,23.54491307147465,8 +Random,80.0,21.674018029620147,8 +Random,82.0,19.904861558274344,8 +Random,84.0,18.049259497746345,8 +Random,86.0,16.179974243399922,8 +Random,88.0,14.757244043786248,8 +Random,90.0,14.022054088860303,8 +Random,92.0,13.685125563425663,8 +Random,94.0,13.411300708306534,8 +Random,96.0,13.276561493882836,8 +Random,98.0,13.193818415969115,8 +Random,100.0,13.099645846748253,8 +Random,102.0,13.004668383773362,8 +Random,104.0,12.888441725692227,8 +Random,106.0,12.787347070186753,8 +Random,108.0,12.724726336123645,8 +Random,110.0,12.674179008370906,8 +Random,112.0,12.570025756600135,8 +Random,114.0,12.487443657437224,8 +Random,116.0,12.424822923374121,8 +Random,118.0,12.335801674179013,8 +Random,120.0,12.296522858982621,8 +Random,2.0,97.98486799742435,9 +Random,4.0,95.99629748873143,9 +Random,6.0,93.98470701867345,9 +Random,8.0,91.98969735994841,9 +Random,10.0,89.99227301996126,9 +Random,12.0,87.99806825499023,9 +Random,14.0,85.98647778493228,9 +Random,16.0,83.99919510624588,9 +Random,18.0,81.98857050869282,9 +Random,20.0,79.9882485511912,9 +Random,22.0,77.98905344494524,9 +Random,24.0,75.99871216999352,9 +Random,26.0,73.99420476497099,9 +Random,28.0,71.99130714745652,9 +Random,30.0,69.98502897617517,9 +Random,32.0,67.99774629748887,9 +Random,34.0,65.99211204121073,9 +Random,36.0,63.98712169993577,9 +Random,38.0,61.90148100450759,9 +Random,40.0,59.99629748873168,9 +Random,42.0,57.99919510624617,9 +Random,44.0,55.99774629748892,9 +Random,46.0,53.99323889246636,9 +Random,48.0,51.97714101738586,9 +Random,50.0,49.98390212491965,9 +Random,52.0,47.97762395363825,9 +Random,54.0,45.989858338699406,9 +Random,56.0,43.99388280746951,9 +Random,58.0,41.99179008370906,9 +Random,60.0,39.990824211204206,9 +Random,62.0,38.125885383129486,9 +Random,64.0,36.245653573728305,9 +Random,66.0,34.245975531229924,9 +Random,68.0,32.38200257566005,9 +Random,70.0,30.757083065035474,9 +Random,72.0,28.769639407598252,9 +Random,74.0,26.766902768834576,9 +Random,76.0,24.769961365099878,9 +Random,78.0,22.765775917578956,9 +Random,80.0,20.768673535093424,9 +Random,82.0,18.89053444945272,9 +Random,84.0,17.02817128139089,9 +Random,86.0,15.299581455247935,9 +Random,88.0,14.44349645846751,9 +Random,90.0,13.79137153895689,9 +Random,92.0,13.45057952350293,9 +Random,94.0,13.197842884739245,9 +Random,96.0,13.006117192530612,9 +Random,98.0,12.895041854475236,9 +Random,100.0,12.771893110109492,9 +Random,102.0,12.682227945911167,9 +Random,104.0,12.597714101738594,9 +Random,106.0,12.515132002575683,9 +Random,108.0,12.407437218287209,9 +Random,110.0,12.34996780424986,9 +Random,112.0,12.25708306503544,9 +Random,114.0,12.21699935608502,9 +Random,116.0,12.162266580811357,9 +Random,118.0,12.131358660656817,9 +Random,120.0,12.115260785576327,9 +BestFit,2.0,97.99822923374111,0 +BestFit,4.0,95.9859948486799,0 +BestFit,6.0,93.98502897617504,0 +BestFit,8.0,91.98535093367668,0 +BestFit,10.0,89.99581455247905,0 +BestFit,12.0,87.99549259497745,0 +BestFit,14.0,85.99420476497104,0 +BestFit,16.0,83.9719896973599,0 +BestFit,18.0,81.98840952994198,0 +BestFit,20.0,79.9916291049581,0 +BestFit,22.0,77.99259497746293,0 +BestFit,24.0,75.99388280746938,0 +BestFit,26.0,73.99275595621376,0 +BestFit,28.0,71.98776561493887,0 +BestFit,30.0,69.99726336123635,0 +BestFit,32.0,67.97987765614945,0 +BestFit,34.0,65.99710238248568,0 +BestFit,36.0,63.94687701223454,0 +BestFit,38.0,61.96571152607871,0 +BestFit,40.0,59.98696072118494,0 +BestFit,42.0,57.995814552479196,0 +BestFit,44.0,55.99195106245989,0 +BestFit,46.0,53.996297488731614,0 +BestFit,48.0,51.990663232453436,0 +BestFit,50.0,49.991629104958264,0 +BestFit,52.0,47.93882807469424,0 +BestFit,54.0,45.98985833869939,0 +BestFit,56.0,43.9840631036704,0 +BestFit,58.0,41.98873148744372,0 +BestFit,60.0,39.98921442369613,0 +BestFit,62.0,37.994365743721865,0 +BestFit,64.0,35.988731487443694,0 +BestFit,66.0,33.9956535737283,0 +BestFit,68.0,31.995331616226668,0 +BestFit,70.0,29.999517063747593,0 +BestFit,72.0,27.99565357372828,0 +BestFit,74.0,25.962330972311676,0 +BestFit,76.0,23.987282678686444,0 +BestFit,78.0,21.990663232453343,0 +BestFit,80.0,19.98551191242759,0 +BestFit,82.0,17.991307147456563,0 +BestFit,84.0,15.929491307147483,0 +BestFit,86.0,13.997102382485538,0 +BestFit,88.0,11.985672891178394,0 +BestFit,90.0,9.997907276239548,0 +BestFit,92.0,7.999195106245955,0 +BestFit,94.0,6.87169993560848,0 +BestFit,96.0,6.866065679330309,0 +BestFit,98.0,6.858338699291674,0 +BestFit,100.0,6.839665164198307,0 +BestFit,102.0,6.836284610431403,0 +BestFit,104.0,6.829362524146794,0 +BestFit,106.0,6.810688989053427,0 +BestFit,108.0,6.804732775273645,0 +BestFit,110.0,6.793142305215694,0 +BestFit,112.0,6.7735028976174965,0 +BestFit,114.0,6.770927237604618,0 +BestFit,116.0,6.747102382485494,0 +BestFit,118.0,6.741951062459737,0 +BestFit,120.0,6.7229555698647605,0 +BestFit,2.0,97.98921442369604,1 +BestFit,4.0,95.99291693496448,1 +BestFit,6.0,93.98679974243387,1 +BestFit,8.0,91.97488731487435,1 +BestFit,10.0,89.99034127495165,1 +BestFit,12.0,87.99758531873792,1 +BestFit,14.0,85.99597553122987,1 +BestFit,16.0,83.98824855119119,1 +BestFit,18.0,81.9898583386992,1 +BestFit,20.0,79.99661944623308,1 +BestFit,22.0,77.9872826786864,1 +BestFit,24.0,75.99597553122987,1 +BestFit,26.0,73.9959755312299,1 +BestFit,28.0,71.98824855119132,1 +BestFit,30.0,69.99227301996146,1 +BestFit,32.0,67.99001931745025,1 +BestFit,34.0,65.99855119124292,1 +BestFit,36.0,63.99806825499048,1 +BestFit,38.0,61.98438506117204,1 +BestFit,40.0,59.985672891178474,1 +BestFit,42.0,57.99001931745021,1 +BestFit,44.0,55.9895363811978,1 +BestFit,46.0,53.99758531873804,1 +BestFit,48.0,51.99581455247917,1 +BestFit,50.0,49.896490663232534,1 +BestFit,52.0,47.99871216999365,1 +BestFit,54.0,45.98985833869938,1 +BestFit,56.0,43.990019317450155,1 +BestFit,58.0,41.99726336123638,1 +BestFit,60.0,39.991790083709,1 +BestFit,62.0,37.9954925949775,1 +BestFit,64.0,35.99935608499681,1 +BestFit,66.0,33.99903412749519,1 +BestFit,68.0,31.991146168705747,1 +BestFit,70.0,29.997585318737947,1 +BestFit,72.0,27.98792659368965,1 +BestFit,74.0,25.998873148744376,1 +BestFit,76.0,23.994365743721843,1 +BestFit,78.0,21.993721828718627,1 +BestFit,80.0,19.9863168061816,1 +BestFit,82.0,17.993399871217015,1 +BestFit,84.0,15.987765614938851,1 +BestFit,86.0,13.993399871217015,1 +BestFit,88.0,11.999034127495184,1 +BestFit,90.0,9.990824211204117,1 +BestFit,92.0,7.99050225370249,1 +BestFit,94.0,7.038312942691544,1 +BestFit,96.0,7.011912427559541,1 +BestFit,98.0,7.006761107533784,1 +BestFit,100.0,6.997263361236294,1 +BestFit,102.0,6.965067611075315,1 +BestFit,104.0,6.953960077269778,1 +BestFit,106.0,6.948003863489996,1 +BestFit,108.0,6.930135222150653,1 +BestFit,110.0,6.930135222150653,1 +BestFit,112.0,6.902446877012211,1 +BestFit,114.0,6.880392788151939,1 +BestFit,116.0,6.843045717965203,1 +BestFit,118.0,6.8258209916290795,1 +BestFit,120.0,6.796844816484199,1 +BestFit,2.0,97.93206696716034,2 +BestFit,4.0,95.99517063747578,2 +BestFit,6.0,93.98889246619437,2 +BestFit,8.0,91.98712169993554,2 +BestFit,10.0,89.98712169993559,2 +BestFit,12.0,87.99951706374756,2 +BestFit,14.0,85.99565357372826,2 +BestFit,16.0,83.98712169993554,2 +BestFit,18.0,81.99629748873139,2 +BestFit,20.0,79.98873148744353,2 +BestFit,22.0,77.99356084996771,2 +BestFit,24.0,75.99726336123621,2 +BestFit,26.0,73.99710238248544,2 +BestFit,28.0,71.99935608499679,2 +BestFit,30.0,69.99372182871862,2 +BestFit,32.0,67.98857050869293,2 +BestFit,34.0,65.99420476497114,2 +BestFit,36.0,63.98309723116561,2 +BestFit,38.0,61.99758531873803,2 +BestFit,40.0,59.98905344494536,2 +BestFit,42.0,57.99195106245985,2 +BestFit,44.0,55.996619446233176,2 +BestFit,46.0,53.99243399871225,2 +BestFit,48.0,51.98728267868651,2 +BestFit,50.0,49.99645846748238,2 +BestFit,52.0,47.99533161622672,2 +BestFit,54.0,45.990663232453386,2 +BestFit,56.0,43.990824211204185,2 +BestFit,58.0,41.995492594977534,2 +BestFit,60.0,39.99404378622028,2 +BestFit,62.0,37.995009658725095,2 +BestFit,64.0,35.99452672247266,2 +BestFit,66.0,33.99372182871863,2 +BestFit,68.0,31.993560849967817,2 +BestFit,70.0,29.99935608499679,2 +BestFit,72.0,27.991790083708963,2 +BestFit,74.0,25.99855119124277,2 +BestFit,76.0,23.999195106245985,2 +BestFit,78.0,21.995331616226668,2 +BestFit,80.0,19.9930779137154,2 +BestFit,82.0,17.98406310367033,2 +BestFit,84.0,15.991790083708967,2 +BestFit,86.0,13.995492594977483,2 +BestFit,88.0,11.997907276239555,2 +BestFit,90.0,9.994848679974254,2 +BestFit,92.0,7.990985189954902,2 +BestFit,94.0,7.203638119768168,2 +BestFit,96.0,7.182388924661923,2 +BestFit,98.0,7.166291049581433,2 +BestFit,100.0,7.150837089504164,2 +BestFit,102.0,7.136992916934943,2 +BestFit,104.0,7.113168061815818,2 +BestFit,106.0,7.105441081777183,2 +BestFit,108.0,7.105441081777183,2 +BestFit,110.0,7.092562781712792,2 +BestFit,112.0,7.079684481648401,2 +BestFit,114.0,7.053283966516398,2 +BestFit,116.0,7.038634900193151,2 +BestFit,118.0,7.038634900193151,2 +BestFit,120.0,7.030907920154518,2 +BestFit,2.0,97.99694140373472,3 +BestFit,4.0,95.99388280746938,3 +BestFit,6.0,93.99919510624593,3 +BestFit,8.0,91.99661944623307,3 +BestFit,10.0,89.99661944623308,3 +BestFit,12.0,87.99146812620735,3 +BestFit,14.0,85.98921442369611,3 +BestFit,16.0,83.9847070186735,3 +BestFit,18.0,81.98486799742427,3 +BestFit,20.0,79.98583386992915,3 +BestFit,22.0,77.99066323245329,3 +BestFit,24.0,75.99871216999354,3 +BestFit,26.0,73.99146812620731,3 +BestFit,28.0,71.99291693496458,3 +BestFit,30.0,69.9951706374759,3 +BestFit,32.0,67.99903412749525,3 +BestFit,34.0,65.98551191242768,3 +BestFit,36.0,63.99597553122997,3 +BestFit,38.0,61.98776561493894,3 +BestFit,40.0,59.9806825499035,3 +BestFit,42.0,57.996297488731564,3 +BestFit,44.0,55.99050225370259,3 +BestFit,46.0,53.99066323245341,3 +BestFit,48.0,51.99871216999365,3 +BestFit,50.0,49.98953638119777,3 +BestFit,52.0,47.98551191242765,3 +BestFit,54.0,45.98535093367684,3 +BestFit,56.0,43.997907276239616,3 +BestFit,58.0,41.98631680618167,3 +BestFit,60.0,39.98406310367039,3 +BestFit,62.0,37.98776561493889,3 +BestFit,64.0,35.984385061171956,3 +BestFit,66.0,33.97392144236962,3 +BestFit,68.0,31.997907276239545,3 +BestFit,70.0,29.99533161622668,3 +BestFit,72.0,27.98792659368965,3 +BestFit,74.0,25.9896973599485,3 +BestFit,76.0,23.998551191242772,3 +BestFit,78.0,21.99806825499035,3 +BestFit,80.0,19.999195106245985,3 +BestFit,82.0,17.992433998712183,3 +BestFit,84.0,15.999195106245988,3 +BestFit,86.0,13.995170637475871,3 +BestFit,88.0,11.995653573728283,3 +BestFit,90.0,9.996780424983912,3 +BestFit,92.0,7.9972633612362936,3 +BestFit,94.0,7.438667095943312,3 +BestFit,96.0,7.415647134578212,3 +BestFit,98.0,7.396973599484845,3 +BestFit,100.0,7.390051513200234,3 +BestFit,102.0,7.384900193174477,3 +BestFit,104.0,7.3797488731487215,3 +BestFit,106.0,7.300708306503519,3 +BestFit,108.0,7.294752092723739,3 +BestFit,110.0,7.274307791371516,3 +BestFit,112.0,7.267385705086905,3 +BestFit,114.0,7.241790083708928,3 +BestFit,116.0,7.224565357372806,3 +BestFit,118.0,7.201545396007707,3 +BestFit,120.0,7.169349645846726,3 +BestFit,2.0,97.99661944623314,4 +BestFit,4.0,95.99629748873146,4 +BestFit,6.0,93.99983902124916,4 +BestFit,8.0,91.9971023824855,4 +BestFit,10.0,89.9972633612363,4 +BestFit,12.0,87.98792659368962,4 +BestFit,14.0,85.99323889246621,4 +BestFit,16.0,83.99227301996136,4 +BestFit,18.0,81.99533161622657,4 +BestFit,20.0,79.99034127495156,4 +BestFit,22.0,77.99565357372813,4 +BestFit,24.0,75.9942047649709,4 +BestFit,26.0,73.93947198969725,4 +BestFit,28.0,71.99710238248544,4 +BestFit,30.0,69.9945267224726,4 +BestFit,32.0,67.90534449452679,4 +BestFit,34.0,65.99710238248568,4 +BestFit,36.0,63.98358016741804,4 +BestFit,38.0,61.995170637475994,4 +BestFit,40.0,59.9888924661946,4 +BestFit,42.0,57.99710238248564,4 +BestFit,44.0,55.996297488731614,4 +BestFit,46.0,53.99887314874447,4 +BestFit,48.0,51.99871216999367,4 +BestFit,50.0,49.993238892466294,4 +BestFit,52.0,47.99452672247273,4 +BestFit,54.0,45.993560849967906,4 +BestFit,56.0,43.99484867997432,4 +BestFit,58.0,41.98953638119775,4 +BestFit,60.0,39.99082421120418,4 +BestFit,62.0,37.99114616870579,4 +BestFit,64.0,35.9948486799743,4 +BestFit,66.0,33.99146812620737,4 +BestFit,68.0,31.98889246619448,4 +BestFit,70.0,29.997424339987138,4 +BestFit,72.0,27.99018029620092,4 +BestFit,74.0,25.9993560849968,4 +BestFit,76.0,23.99533161622668,4 +BestFit,78.0,21.996941403734727,4 +BestFit,80.0,19.9929169349646,4 +BestFit,82.0,18.000000000000014,4 +BestFit,84.0,15.985833869929191,4 +BestFit,86.0,13.990663232453343,4 +BestFit,88.0,11.984707018673568,4 +BestFit,90.0,9.994687701223457,4 +BestFit,92.0,7.9969414037346915,4 +BestFit,94.0,7.064069542820333,4 +BestFit,96.0,7.053766902768818,4 +BestFit,98.0,7.01963940759818,4 +BestFit,100.0,7.001609787508032,4 +BestFit,102.0,6.974243399871201,4 +BestFit,104.0,6.956374758531856,4 +BestFit,106.0,6.9512234385061005,4 +BestFit,108.0,6.917900837089487,4 +BestFit,110.0,6.908403090791998,4 +BestFit,112.0,6.9058274307791185,4 +BestFit,114.0,6.86928525434641,4 +BestFit,116.0,6.835801674178993,4 +BestFit,118.0,6.8272698003863335,4 +BestFit,120.0,6.811815840309064,4 +BestFit,2.0,97.98164842240824,5 +BestFit,4.0,95.9890534449452,5 +BestFit,6.0,93.99098518995484,5 +BestFit,8.0,91.995814552479,5 +BestFit,10.0,89.98470701867349,5 +BestFit,12.0,87.99919510624596,5 +BestFit,14.0,85.99661944623314,5 +BestFit,16.0,83.99887314874441,5 +BestFit,18.0,81.99034127495167,5 +BestFit,20.0,79.99533161622665,5 +BestFit,22.0,77.99436574372183,5 +BestFit,24.0,75.99468770122341,5 +BestFit,26.0,73.99565357372829,5 +BestFit,28.0,71.99983902124923,5 +BestFit,30.0,69.99001931745009,5 +BestFit,32.0,67.99468770122353,5 +BestFit,34.0,65.99034127495187,5 +BestFit,36.0,63.994687701223604,5 +BestFit,38.0,61.99339987121715,5 +BestFit,40.0,59.99130714745667,5 +BestFit,42.0,57.99098518995507,5 +BestFit,44.0,55.99356084996795,5 +BestFit,46.0,53.994687701223576,5 +BestFit,48.0,51.92289117836457,5 +BestFit,50.0,49.988570508692966,5 +BestFit,52.0,47.99983902124927,5 +BestFit,54.0,45.92305215711535,5 +BestFit,56.0,43.998068254990415,5 +BestFit,58.0,41.99790727623961,5 +BestFit,60.0,39.99018029620097,5 +BestFit,62.0,37.94011590470064,5 +BestFit,64.0,35.98792659368966,5 +BestFit,66.0,33.9932388924662,5 +BestFit,68.0,31.994043786220228,5 +BestFit,70.0,29.99356084996781,5 +BestFit,72.0,27.99742433998713,5 +BestFit,74.0,25.992273019961377,5 +BestFit,76.0,23.989858338699303,5 +BestFit,78.0,21.915164198325826,5 +BestFit,80.0,19.994204764971037,5 +BestFit,82.0,17.999839021249212,5 +BestFit,84.0,15.991468126207357,5 +BestFit,86.0,13.984546039922746,5 +BestFit,88.0,11.991307147456553,5 +BestFit,90.0,9.987604636188014,5 +BestFit,92.0,7.9880875724404135,5 +BestFit,94.0,7.071474565357348,5 +BestFit,96.0,7.047649710238224,5 +BestFit,98.0,7.045074050225346,5 +BestFit,100.0,7.0321957501609536,5 +BestFit,102.0,7.014327108821611,5 +BestFit,104.0,7.012556342562758,5 +BestFit,106.0,7.0099806825498785,5 +BestFit,108.0,7.003863490019293,5 +BestFit,110.0,6.967804249838997,5 +BestFit,112.0,6.960077269800362,5 +BestFit,114.0,6.9285254346426015,5 +BestFit,116.0,6.921603348357992,5 +BestFit,118.0,6.9146812620733815,5 +BestFit,120.0,6.905183515775892,5 +BestFit,2.0,97.98824855119122,6 +BestFit,4.0,95.98551191242747,6 +BestFit,6.0,93.99227301996133,6 +BestFit,8.0,91.99645846748226,6 +BestFit,10.0,89.94510624597548,6 +BestFit,12.0,87.99388280746938,6 +BestFit,14.0,85.99372182871858,6 +BestFit,16.0,83.99565357372823,6 +BestFit,18.0,81.98599484867984,6 +BestFit,20.0,79.99774629748863,6 +BestFit,22.0,77.98889246619436,6 +BestFit,24.0,75.99356084996772,6 +BestFit,26.0,73.9959755312298,6 +BestFit,28.0,71.98422408242105,6 +BestFit,30.0,69.98180940115901,6 +BestFit,32.0,67.99227301996137,6 +BestFit,34.0,65.99339987121712,6 +BestFit,36.0,63.99517063747595,6 +BestFit,38.0,61.995009658725145,6 +BestFit,40.0,59.98390212491961,6 +BestFit,42.0,57.99452672247271,6 +BestFit,44.0,55.99645846748238,6 +BestFit,46.0,53.98792659368973,6 +BestFit,48.0,51.998390212492055,6 +BestFit,50.0,49.99951706374768,6 +BestFit,52.0,47.98921442369617,6 +BestFit,54.0,45.99726336123641,6 +BestFit,56.0,43.9938828074695,6 +BestFit,58.0,41.99919510624605,6 +BestFit,60.0,39.99339987121707,6 +BestFit,62.0,37.99549259497752,6 +BestFit,64.0,35.98470701867358,6 +BestFit,66.0,33.987121699935635,6 +BestFit,68.0,31.987121699935628,6 +BestFit,70.0,29.984063103670326,6 +BestFit,72.0,27.993077913715403,6 +BestFit,74.0,25.99420476497103,6 +BestFit,76.0,23.993721828718623,6 +BestFit,78.0,21.998712169993574,6 +BestFit,80.0,19.98116548615584,6 +BestFit,82.0,17.996458467482306,6 +BestFit,84.0,15.996780424983914,6 +BestFit,86.0,13.996136509980692,6 +BestFit,88.0,11.998229233741156,6 +BestFit,90.0,9.990019317450113,6 +BestFit,92.0,7.989375402446859,6 +BestFit,94.0,6.994204764971007,6 +BestFit,96.0,6.992433998712152,6 +BestFit,98.0,6.9652285898261255,6 +BestFit,100.0,6.949774629748856,6 +BestFit,102.0,6.922569220862829,6 +BestFit,104.0,6.910817772054073,6 +BestFit,106.0,6.908242112041194,6 +BestFit,108.0,6.900515132002559,6 +BestFit,110.0,6.890212491951046,6 +BestFit,112.0,6.88506117192529,6 +BestFit,114.0,6.8729877656149245,6 +BestFit,116.0,6.865260785576288,6 +BestFit,118.0,6.854153251770753,6 +BestFit,120.0,6.833708950418532,6 +BestFit,2.0,97.99533161622666,7 +BestFit,4.0,95.99372182871852,7 +BestFit,6.0,93.99951706374748,7 +BestFit,8.0,91.99195106245965,7 +BestFit,10.0,89.99275595621373,7 +BestFit,12.0,87.99806825499033,7 +BestFit,14.0,85.98760463618805,7 +BestFit,16.0,83.9938828074694,7 +BestFit,18.0,81.9851899549259,7 +BestFit,20.0,79.9954925949774,7 +BestFit,22.0,77.99613650998066,7 +BestFit,24.0,75.98969735994848,7 +BestFit,26.0,73.98857050869286,7 +BestFit,28.0,71.98567289117842,7 +BestFit,30.0,69.99549259497752,7 +BestFit,32.0,67.99661944623323,7 +BestFit,34.0,65.99613650998086,7 +BestFit,36.0,63.97794591113989,7 +BestFit,38.0,61.98921442369622,7 +BestFit,40.0,59.99855119124289,7 +BestFit,42.0,57.99356084996794,7 +BestFit,44.0,55.98615582743089,7 +BestFit,46.0,53.965228589826275,7 +BestFit,48.0,51.949935608499786,7 +BestFit,50.0,49.98696072118491,7 +BestFit,52.0,47.98454603992282,7 +BestFit,54.0,45.973116548615664,7 +BestFit,56.0,43.99774629748879,7 +BestFit,58.0,41.990180296200954,7 +BestFit,60.0,39.998873148744416,7 +BestFit,62.0,37.99935608499682,7 +BestFit,64.0,35.99822923374118,7 +BestFit,66.0,33.99420476497102,7 +BestFit,68.0,31.989697359948494,7 +BestFit,70.0,29.9866387636832,7 +BestFit,72.0,27.991951062459762,7 +BestFit,74.0,25.996136509980694,7 +BestFit,76.0,23.999839021249212,7 +BestFit,78.0,21.99259497746299,7 +BestFit,80.0,19.985672891178382,7 +BestFit,82.0,17.984063103670344,7 +BestFit,84.0,15.984707018673564,7 +BestFit,86.0,13.997585318737956,7 +BestFit,88.0,11.987604636188056,7 +BestFit,90.0,9.98470701867355,7 +BestFit,92.0,7.92916934964583,7 +BestFit,94.0,7.124275595621361,7 +BestFit,96.0,7.097070186735334,7 +BestFit,98.0,7.063103670315502,7 +BestFit,100.0,7.045074050225354,7 +BestFit,102.0,7.033966516419817,7 +BestFit,104.0,7.015936896329668,7 +BestFit,106.0,7.006439150032179,7 +BestFit,108.0,6.990180296200885,7 +BestFit,110.0,6.987604636188006,7 +BestFit,112.0,6.983258209916275,7 +BestFit,114.0,6.978106889890519,7 +BestFit,116.0,6.963457823567273,7 +BestFit,118.0,6.949774629748857,7 +BestFit,120.0,6.942852543464248,7 +BestFit,2.0,97.98760463618801,8 +BestFit,4.0,95.9879265936896,8 +BestFit,6.0,93.98969735994844,8 +BestFit,8.0,91.995009658725,8 +BestFit,10.0,89.99130714745654,8 +BestFit,12.0,87.98502897617517,8 +BestFit,14.0,85.99339987121704,8 +BestFit,16.0,83.9959755312299,8 +BestFit,18.0,81.99855119124271,8 +BestFit,20.0,79.9967804249839,8 +BestFit,22.0,77.99629748873147,8 +BestFit,24.0,75.99050225370254,8 +BestFit,26.0,73.99758531873795,8 +BestFit,28.0,71.91870573084358,8 +BestFit,30.0,69.99130714745657,8 +BestFit,32.0,67.99066323245341,8 +BestFit,34.0,65.99839021249207,8 +BestFit,36.0,63.9935608499679,8 +BestFit,38.0,61.98551191242765,8 +BestFit,40.0,59.9840631036704,8 +BestFit,42.0,57.98824855119133,8 +BestFit,44.0,55.99951706374768,8 +BestFit,46.0,53.92627173213145,8 +BestFit,48.0,51.98873148744375,8 +BestFit,50.0,49.87974887314883,8 +BestFit,52.0,47.99372182871869,8 +BestFit,54.0,45.987443657437304,8 +BestFit,56.0,43.985833869929216,8 +BestFit,58.0,41.997585318737976,8 +BestFit,60.0,39.99742433998716,8 +BestFit,62.0,37.99935608499682,8 +BestFit,64.0,35.998229233741185,8 +BestFit,66.0,33.984385061171956,8 +BestFit,68.0,31.990502253702534,8 +BestFit,70.0,29.99887314874438,8 +BestFit,72.0,27.993077913715403,8 +BestFit,74.0,25.99323889246621,8 +BestFit,76.0,23.99790727623955,8 +BestFit,78.0,21.999517063747597,8 +BestFit,80.0,19.999839021249205,8 +BestFit,82.0,17.97311654861559,8 +BestFit,84.0,15.988731487443667,8 +BestFit,86.0,13.99066323245332,8 +BestFit,88.0,11.988409529942059,8 +BestFit,90.0,9.997585318737924,8 +BestFit,92.0,7.985833869929146,8 +BestFit,94.0,6.555859626529273,8 +BestFit,96.0,6.555859626529273,8 +BestFit,98.0,6.5540888602704195,8 +BestFit,100.0,6.52945911139727,8 +BestFit,102.0,6.511590470057927,8 +BestFit,104.0,6.486155827430755,8 +BestFit,106.0,6.479233741146144,8 +BestFit,108.0,6.474887314874413,8 +BestFit,110.0,6.46893110109463,8 +BestFit,112.0,6.46200901481002,8 +BestFit,114.0,6.456857694784262,8 +BestFit,116.0,6.451706374758507,8 +BestFit,118.0,6.4356084996780165,8 +BestFit,120.0,6.43045717965226,8 +BestFit,2.0,97.98486799742436,9 +BestFit,4.0,95.99629748873144,9 +BestFit,6.0,93.98470701867352,9 +BestFit,8.0,91.98969735994847,9 +BestFit,10.0,89.99227301996132,9 +BestFit,12.0,87.99806825499033,9 +BestFit,14.0,85.98647778493239,9 +BestFit,16.0,83.99919510624592,9 +BestFit,18.0,81.98857050869279,9 +BestFit,20.0,79.98824855119116,9 +BestFit,22.0,77.98905344494521,9 +BestFit,24.0,75.99871216999352,9 +BestFit,26.0,73.994204764971,9 +BestFit,28.0,71.99130714745652,9 +BestFit,30.0,69.98502897617514,9 +BestFit,32.0,67.99774629748883,9 +BestFit,34.0,65.99211204121072,9 +BestFit,36.0,63.987121699935756,9 +BestFit,38.0,61.901481004507545,9 +BestFit,40.0,59.99629748873162,9 +BestFit,42.0,57.99919510624609,9 +BestFit,44.0,55.997746297488845,9 +BestFit,46.0,53.9932388924663,9 +BestFit,48.0,51.97714101738582,9 +BestFit,50.0,49.98390212491963,9 +BestFit,52.0,47.97762395363822,9 +BestFit,54.0,45.98985833869939,9 +BestFit,56.0,43.9938828074695,9 +BestFit,58.0,41.99179008370903,9 +BestFit,60.0,39.9908242112042,9 +BestFit,62.0,37.99710238248557,9 +BestFit,64.0,35.98808757244048,9 +BestFit,66.0,33.98840952994207,9 +BestFit,68.0,31.995653573728266,9 +BestFit,70.0,29.984385061171924,9 +BestFit,72.0,27.996941403734706,9 +BestFit,74.0,25.99420476497102,9 +BestFit,76.0,23.997263361236318,9 +BestFit,78.0,21.993077913715386,9 +BestFit,80.0,19.995975531229877,9 +BestFit,82.0,17.989053444945277,9 +BestFit,84.0,15.997907276239554,9 +BestFit,86.0,13.995653573728287,9 +BestFit,88.0,11.99661944623312,9 +BestFit,90.0,9.99227301996138,9 +BestFit,92.0,7.994848679974222,9 +BestFit,94.0,6.999517063747565,9 +BestFit,96.0,6.978106889890514,9 +BestFit,98.0,6.971667739858319,9 +BestFit,100.0,6.936735350933657,9 +BestFit,102.0,6.934159690920777,9 +BestFit,104.0,6.9256278171281185,9 +BestFit,106.0,6.921281390856386,9 +BestFit,108.0,6.879587894397919,9 +BestFit,110.0,6.871538956857674,9 +BestFit,112.0,6.866387636831918,9 +BestFit,114.0,6.864616870573063,9 +BestFit,116.0,6.835640695428183,9 +BestFit,118.0,6.835640695428183,9 +BestFit,120.0,6.819542820347693,9 +BestFit-PN,2.0,97.99822923374114,0 +BestFit-PN,4.0,95.98599484867997,0 +BestFit-PN,6.0,93.98502897617516,0 +BestFit-PN,8.0,91.98535093367676,0 +BestFit-PN,10.0,89.99581455247908,0 +BestFit-PN,12.0,87.99549259497745,0 +BestFit-PN,14.0,85.99420476497103,0 +BestFit-PN,16.0,83.97198969735994,0 +BestFit-PN,18.0,81.98840952994205,0 +BestFit-PN,20.0,79.99162910495814,0 +BestFit-PN,22.0,77.99259497746297,0 +BestFit-PN,24.0,75.99388280746942,0 +BestFit-PN,26.0,73.99275595621378,0 +BestFit-PN,28.0,71.98776561493882,0 +BestFit-PN,30.0,69.9972633612363,0 +BestFit-PN,32.0,67.97987765614938,0 +BestFit-PN,34.0,65.99710238248551,0 +BestFit-PN,36.0,63.94687701223438,0 +BestFit-PN,38.0,61.96571152607856,0 +BestFit-PN,40.0,59.9869607211848,0 +BestFit-PN,42.0,57.995814552479075,0 +BestFit-PN,44.0,55.991951062459755,0 +BestFit-PN,46.0,53.99629748873149,0 +BestFit-PN,48.0,51.990663232453315,0 +BestFit-PN,50.0,49.99162910495814,0 +BestFit-PN,52.0,47.93882807469414,0 +BestFit-PN,54.0,45.98985833869928,0 +BestFit-PN,56.0,43.98406310367031,0 +BestFit-PN,58.0,41.98873148744365,0 +BestFit-PN,60.0,39.98921442369607,0 +BestFit-PN,62.0,37.99436574372182,0 +BestFit-PN,64.0,35.98873148744365,0 +BestFit-PN,66.0,33.995653573728255,0 +BestFit-PN,68.0,31.99533161622665,0 +BestFit-PN,70.0,29.99951706374758,0 +BestFit-PN,72.0,27.99565357372826,0 +BestFit-PN,74.0,25.96233097231164,0 +BestFit-PN,76.0,23.9872826786864,0 +BestFit-PN,78.0,21.990663232453304,0 +BestFit-PN,80.0,19.985511912427548,0 +BestFit-PN,82.0,17.991307147456524,0 +BestFit-PN,84.0,15.929491307147442,0 +BestFit-PN,86.0,13.9971023824855,0 +BestFit-PN,88.0,11.985672891178353,0 +BestFit-PN,90.0,9.997907276239525,0 +BestFit-PN,92.0,7.999195106245965,0 +BestFit-PN,94.0,6.4576625885383,0 +BestFit-PN,96.0,6.452028332260127,0 +BestFit-PN,98.0,6.444301352221495,0 +BestFit-PN,100.0,6.425627817128128,0 +BestFit-PN,102.0,6.422247263361225,0 +BestFit-PN,104.0,6.415325177076614,0 +BestFit-PN,106.0,6.396651641983246,0 +BestFit-PN,108.0,6.390695428203465,0 +BestFit-PN,110.0,6.379104958145512,0 +BestFit-PN,112.0,6.359465550547316,0 +BestFit-PN,114.0,6.356889890534437,0 +BestFit-PN,116.0,6.333065035415314,0 +BestFit-PN,118.0,6.327913715389556,0 +BestFit-PN,120.0,6.308918222794578,0 +BestFit-PN,2.0,97.98921442369607,1 +BestFit-PN,4.0,95.99291693496458,1 +BestFit-PN,6.0,93.986799742434,1 +BestFit-PN,8.0,91.97488731487444,1 +BestFit-PN,10.0,89.9903412749517,1 +BestFit-PN,12.0,87.99758531873792,1 +BestFit-PN,14.0,85.99597553122987,1 +BestFit-PN,16.0,83.98824855119125,1 +BestFit-PN,18.0,81.98985833869929,1 +BestFit-PN,20.0,79.99661944623308,1 +BestFit-PN,22.0,77.98728267868641,1 +BestFit-PN,24.0,75.99597553122987,1 +BestFit-PN,26.0,73.99597553122987,1 +BestFit-PN,28.0,71.98824855119123,1 +BestFit-PN,30.0,69.99227301996137,1 +BestFit-PN,32.0,67.9900193174501,1 +BestFit-PN,34.0,65.99855119124275,1 +BestFit-PN,36.0,63.998068254990336,1 +BestFit-PN,38.0,61.98438506117192,1 +BestFit-PN,40.0,59.98567289117835,1 +BestFit-PN,42.0,57.99001931745009,1 +BestFit-PN,44.0,55.98953638119768,1 +BestFit-PN,46.0,53.997585318737926,1 +BestFit-PN,48.0,51.99581455247907,1 +BestFit-PN,50.0,49.89649066323245,1 +BestFit-PN,52.0,47.99871216999356,1 +BestFit-PN,54.0,45.98985833869928,1 +BestFit-PN,56.0,43.9900193174501,1 +BestFit-PN,58.0,41.997263361236314,1 +BestFit-PN,60.0,39.99179008370894,1 +BestFit-PN,62.0,37.995492594977456,1 +BestFit-PN,64.0,35.999356084996776,1 +BestFit-PN,66.0,33.999034127495165,1 +BestFit-PN,68.0,31.991146168705725,1 +BestFit-PN,70.0,29.99758531873792,1 +BestFit-PN,72.0,27.98792659368962,1 +BestFit-PN,74.0,25.998873148744355,1 +BestFit-PN,76.0,23.994365743721822,1 +BestFit-PN,78.0,21.993721828718602,1 +BestFit-PN,80.0,19.986316806181577,1 +BestFit-PN,82.0,17.99339987121699,1 +BestFit-PN,84.0,15.987765614938818,1 +BestFit-PN,86.0,13.993399871216985,1 +BestFit-PN,88.0,11.999034127495158,1 +BestFit-PN,90.0,9.990824211204107,1 +BestFit-PN,92.0,7.990502253702495,1 +BestFit-PN,94.0,6.220057952350273,1 +BestFit-PN,96.0,6.193657437218271,1 +BestFit-PN,98.0,6.188506117192514,1 +BestFit-PN,100.0,6.179008370895026,1 +BestFit-PN,102.0,6.146812620734047,1 +BestFit-PN,104.0,6.1357050869285095,1 +BestFit-PN,106.0,6.129748873148729,1 +BestFit-PN,108.0,6.111880231809385,1 +BestFit-PN,110.0,6.111880231809385,1 +BestFit-PN,112.0,6.084191886670945,1 +BestFit-PN,114.0,6.062137797810673,1 +BestFit-PN,116.0,6.024790727623938,1 +BestFit-PN,118.0,6.007566001287815,1 +BestFit-PN,120.0,5.994687701223424,1 +BestFit-PN,2.0,97.93206696716034,2 +BestFit-PN,4.0,95.99517063747585,2 +BestFit-PN,6.0,93.98889246619446,2 +BestFit-PN,8.0,91.9871216999356,2 +BestFit-PN,10.0,89.98712169993561,2 +BestFit-PN,12.0,87.99951706374758,2 +BestFit-PN,14.0,85.99565357372828,2 +BestFit-PN,16.0,83.98712169993561,2 +BestFit-PN,18.0,81.9962974887315,2 +BestFit-PN,20.0,79.98873148744366,2 +BestFit-PN,22.0,77.9935608499678,2 +BestFit-PN,24.0,75.9972633612363,2 +BestFit-PN,26.0,73.99710238248551,2 +BestFit-PN,28.0,71.99935608499679,2 +BestFit-PN,30.0,69.99372182871862,2 +BestFit-PN,32.0,67.98857050869285,2 +BestFit-PN,34.0,65.99420476497102,2 +BestFit-PN,36.0,63.98309723116549,2 +BestFit-PN,38.0,61.997585318737926,2 +BestFit-PN,40.0,59.98905344494526,2 +BestFit-PN,42.0,57.991951062459755,2 +BestFit-PN,44.0,55.9966194462331,2 +BestFit-PN,46.0,53.992433998712166,2 +BestFit-PN,48.0,51.987282678686405,2 +BestFit-PN,50.0,49.99645846748229,2 +BestFit-PN,52.0,47.99533161622666,2 +BestFit-PN,54.0,45.99066323245331,2 +BestFit-PN,56.0,43.99082421120412,2 +BestFit-PN,58.0,41.995492594977456,2 +BestFit-PN,60.0,39.99404378622022,2 +BestFit-PN,62.0,37.995009658725046,2 +BestFit-PN,64.0,35.99452672247263,2 +BestFit-PN,66.0,33.993721828718606,2 +BestFit-PN,68.0,31.993560849967807,2 +BestFit-PN,70.0,29.99935608499678,2 +BestFit-PN,72.0,27.99179008370895,2 +BestFit-PN,74.0,25.998551191242754,2 +BestFit-PN,76.0,23.99919510624597,2 +BestFit-PN,78.0,21.995331616226654,2 +BestFit-PN,80.0,19.993077913715382,2 +BestFit-PN,82.0,17.98406310367031,2 +BestFit-PN,84.0,15.991790083708946,2 +BestFit-PN,86.0,13.995492594977458,2 +BestFit-PN,88.0,11.997907276239527,2 +BestFit-PN,90.0,9.994848679974242,2 +BestFit-PN,92.0,7.990985189954925,2 +BestFit-PN,94.0,6.480843528654215,2 +BestFit-PN,96.0,6.454443013522211,2 +BestFit-PN,98.0,6.438345138441721,2 +BestFit-PN,100.0,6.422891178364451,2 +BestFit-PN,102.0,6.40904700579523,2 +BestFit-PN,104.0,6.385222150676108,2 +BestFit-PN,106.0,6.377495170637472,2 +BestFit-PN,108.0,6.377495170637472,2 +BestFit-PN,110.0,6.364616870573079,2 +BestFit-PN,112.0,6.351738570508688,2 +BestFit-PN,114.0,6.309240180296197,2 +BestFit-PN,116.0,6.262395363811972,2 +BestFit-PN,118.0,6.262395363811972,2 +BestFit-PN,120.0,6.254668383773337,2 +BestFit-PN,2.0,97.99694140373471,3 +BestFit-PN,4.0,95.9938828074694,3 +BestFit-PN,6.0,93.99919510624596,3 +BestFit-PN,8.0,91.9966194462331,3 +BestFit-PN,10.0,89.9966194462331,3 +BestFit-PN,12.0,87.99146812620734,3 +BestFit-PN,14.0,85.98921442369607,3 +BestFit-PN,16.0,83.98470701867353,3 +BestFit-PN,18.0,81.98486799742433,3 +BestFit-PN,20.0,79.98583386992915,3 +BestFit-PN,22.0,77.99066323245331,3 +BestFit-PN,24.0,75.99871216999357,3 +BestFit-PN,26.0,73.99146812620735,3 +BestFit-PN,28.0,71.99291693496458,3 +BestFit-PN,30.0,69.99517063747585,3 +BestFit-PN,32.0,67.99903412749516,3 +BestFit-PN,34.0,65.98551191242755,3 +BestFit-PN,36.0,63.99597553122987,3 +BestFit-PN,38.0,61.987765614938816,3 +BestFit-PN,40.0,59.980682549903406,3 +BestFit-PN,42.0,57.996297488731486,3 +BestFit-PN,44.0,55.9905022537025,3 +BestFit-PN,46.0,53.99066323245331,3 +BestFit-PN,48.0,51.99871216999355,3 +BestFit-PN,50.0,49.989536381197674,3 +BestFit-PN,52.0,47.985511912427555,3 +BestFit-PN,54.0,45.98535093367675,3 +BestFit-PN,56.0,43.99790727623953,3 +BestFit-PN,58.0,41.98631680618158,3 +BestFit-PN,60.0,39.98406310367031,3 +BestFit-PN,62.0,37.987765614938816,3 +BestFit-PN,64.0,35.98438506117191,3 +BestFit-PN,66.0,33.973921442369594,3 +BestFit-PN,68.0,31.997907276239523,3 +BestFit-PN,70.0,29.995331616226643,3 +BestFit-PN,72.0,27.98792659368962,3 +BestFit-PN,74.0,25.989697359948472,3 +BestFit-PN,76.0,23.998551191242747,3 +BestFit-PN,78.0,21.99806825499033,3 +BestFit-PN,80.0,19.999195106245967,3 +BestFit-PN,82.0,17.99243399871216,3 +BestFit-PN,84.0,15.999195106245967,3 +BestFit-PN,86.0,13.995170637475841,3 +BestFit-PN,88.0,11.995653573728259,3 +BestFit-PN,90.0,9.996780424983891,3 +BestFit-PN,92.0,7.997263361236305,3 +BestFit-PN,94.0,6.628139085640681,3 +BestFit-PN,96.0,6.605119124275582,3 +BestFit-PN,98.0,6.586445589182214,3 +BestFit-PN,100.0,6.579523502897604,3 +BestFit-PN,102.0,6.574372182871848,3 +BestFit-PN,104.0,6.569220862846091,3 +BestFit-PN,106.0,6.49018029620089,3 +BestFit-PN,108.0,6.484224082421108,3 +BestFit-PN,110.0,6.463779781068886,3 +BestFit-PN,112.0,6.456857694784277,3 +BestFit-PN,114.0,6.431262073406298,3 +BestFit-PN,116.0,6.414037347070174,3 +BestFit-PN,118.0,6.407115260785565,3 +BestFit-PN,120.0,6.374919510624584,3 +BestFit-PN,2.0,97.9966194462331,4 +BestFit-PN,4.0,95.99629748873149,4 +BestFit-PN,6.0,93.9998390212492,4 +BestFit-PN,8.0,91.99710238248552,4 +BestFit-PN,10.0,89.99726336123632,4 +BestFit-PN,12.0,87.98792659368962,4 +BestFit-PN,14.0,85.99323889246618,4 +BestFit-PN,16.0,83.99227301996137,4 +BestFit-PN,18.0,81.99533161622666,4 +BestFit-PN,20.0,79.9903412749517,4 +BestFit-PN,22.0,77.99565357372828,4 +BestFit-PN,24.0,75.99420476497103,4 +BestFit-PN,26.0,73.93947198969735,4 +BestFit-PN,28.0,71.99710238248551,4 +BestFit-PN,30.0,69.99452672247263,4 +BestFit-PN,32.0,67.90534449452672,4 +BestFit-PN,34.0,65.99710238248551,4 +BestFit-PN,36.0,63.9835801674179,4 +BestFit-PN,38.0,61.99517063747585,4 +BestFit-PN,40.0,59.98889246619446,4 +BestFit-PN,42.0,57.99710238248551,4 +BestFit-PN,44.0,55.996297488731486,4 +BestFit-PN,46.0,53.998873148744366,4 +BestFit-PN,48.0,51.99871216999355,4 +BestFit-PN,50.0,49.99323889246619,4 +BestFit-PN,52.0,47.994526722472635,4 +BestFit-PN,54.0,45.9935608499678,4 +BestFit-PN,56.0,43.99484867997425,4 +BestFit-PN,58.0,41.98953638119768,4 +BestFit-PN,60.0,39.990824211204114,4 +BestFit-PN,62.0,37.991146168705725,4 +BestFit-PN,64.0,35.99484867997423,4 +BestFit-PN,66.0,33.99146812620734,4 +BestFit-PN,68.0,31.988892466194457,4 +BestFit-PN,70.0,29.997424339987116,4 +BestFit-PN,72.0,27.990180296200894,4 +BestFit-PN,74.0,25.999356084996773,4 +BestFit-PN,76.0,23.99533161622665,4 +BestFit-PN,78.0,21.996941403734695,4 +BestFit-PN,80.0,19.992916934964576,4 +BestFit-PN,82.0,17.999999999999986,4 +BestFit-PN,84.0,15.98583386992916,4 +BestFit-PN,86.0,13.990663232453304,4 +BestFit-PN,88.0,11.984707018673523,4 +BestFit-PN,90.0,9.994687701223427,4 +BestFit-PN,92.0,7.9969414037346915,4 +BestFit-PN,94.0,5.997102382485496,4 +BestFit-PN,96.0,5.949452672247248,4 +BestFit-PN,98.0,5.91532517707661,4 +BestFit-PN,100.0,5.897295556986462,4 +BestFit-PN,102.0,5.869929169349631,4 +BestFit-PN,104.0,5.868158403090777,4 +BestFit-PN,106.0,5.863007083065021,4 +BestFit-PN,108.0,5.829684481648409,4 +BestFit-PN,110.0,5.820186735350919,4 +BestFit-PN,112.0,5.817611075338042,4 +BestFit-PN,114.0,5.781068898905331,4 +BestFit-PN,116.0,5.7636831938184026,4 +BestFit-PN,118.0,5.7551513200257425,4 +BestFit-PN,120.0,5.739697359948474,4 +BestFit-PN,2.0,97.98164842240824,5 +BestFit-PN,4.0,95.98905344494527,5 +BestFit-PN,6.0,93.99098518995494,5 +BestFit-PN,8.0,91.99581455247908,5 +BestFit-PN,10.0,89.98470701867353,5 +BestFit-PN,12.0,87.99919510624598,5 +BestFit-PN,14.0,85.9966194462331,5 +BestFit-PN,16.0,83.99887314874437,5 +BestFit-PN,18.0,81.9903412749517,5 +BestFit-PN,20.0,79.99533161622665,5 +BestFit-PN,22.0,77.99436574372183,5 +BestFit-PN,24.0,75.99468770122344,5 +BestFit-PN,26.0,73.99565357372826,5 +BestFit-PN,28.0,71.9998390212492,5 +BestFit-PN,30.0,69.99001931745009,5 +BestFit-PN,32.0,67.99468770122343,5 +BestFit-PN,34.0,65.9903412749517,5 +BestFit-PN,36.0,63.99468770122344,5 +BestFit-PN,38.0,61.993399871216994,5 +BestFit-PN,40.0,59.99130714745653,5 +BestFit-PN,42.0,57.99098518995493,5 +BestFit-PN,44.0,55.99356084996781,5 +BestFit-PN,46.0,53.994687701223434,5 +BestFit-PN,48.0,51.92289117836445,5 +BestFit-PN,50.0,49.988570508692845,5 +BestFit-PN,52.0,47.99983902124919,5 +BestFit-PN,54.0,45.92305215711526,5 +BestFit-PN,56.0,43.99806825499033,5 +BestFit-PN,58.0,41.99790727623952,5 +BestFit-PN,60.0,39.9901802962009,5 +BestFit-PN,62.0,37.94011590470057,5 +BestFit-PN,64.0,35.98792659368963,5 +BestFit-PN,66.0,33.99323889246618,5 +BestFit-PN,68.0,31.99404378622021,5 +BestFit-PN,70.0,29.993560849967793,5 +BestFit-PN,72.0,27.99742433998711,5 +BestFit-PN,74.0,25.99227301996135,5 +BestFit-PN,76.0,23.989858338699275,5 +BestFit-PN,78.0,21.915164198325805,5 +BestFit-PN,80.0,19.99420476497101,5 +BestFit-PN,82.0,17.99983902124918,5 +BestFit-PN,84.0,15.991468126207323,5 +BestFit-PN,86.0,13.984546039922712,5 +BestFit-PN,88.0,11.99130714745652,5 +BestFit-PN,90.0,9.987604636188006,5 +BestFit-PN,92.0,7.98808757244042,5 +BestFit-PN,94.0,6.46603348358015,5 +BestFit-PN,96.0,6.438506117192512,5 +BestFit-PN,98.0,6.435930457179634,5 +BestFit-PN,100.0,6.423052157115243,5 +BestFit-PN,102.0,6.4051835157758985,5 +BestFit-PN,104.0,6.403412749517045,5 +BestFit-PN,106.0,6.400837089504168,5 +BestFit-PN,108.0,6.394719896973582,5 +BestFit-PN,110.0,6.358660656793284,5 +BestFit-PN,112.0,6.350933676754651,5 +BestFit-PN,114.0,6.3193818415968925,5 +BestFit-PN,116.0,6.312459755312282,5 +BestFit-PN,118.0,6.305537669027672,5 +BestFit-PN,120.0,6.296039922730183,5 +BestFit-PN,2.0,97.98824855119123,6 +BestFit-PN,4.0,95.98551191242755,6 +BestFit-PN,6.0,93.99227301996137,6 +BestFit-PN,8.0,91.99645846748228,6 +BestFit-PN,10.0,89.94510624597552,6 +BestFit-PN,12.0,87.99388280746942,6 +BestFit-PN,14.0,85.99372182871862,6 +BestFit-PN,16.0,83.99565357372826,6 +BestFit-PN,18.0,81.98599484867998,6 +BestFit-PN,20.0,79.99774629748873,6 +BestFit-PN,22.0,77.98889246619446,6 +BestFit-PN,24.0,75.99356084996779,6 +BestFit-PN,26.0,73.99597553122987,6 +BestFit-PN,28.0,71.98422408242112,6 +BestFit-PN,30.0,69.98180940115905,6 +BestFit-PN,32.0,67.99227301996137,6 +BestFit-PN,34.0,65.99339987121701,6 +BestFit-PN,36.0,63.99517063747585,6 +BestFit-PN,38.0,61.99500965872505,6 +BestFit-PN,40.0,59.98390212491951,6 +BestFit-PN,42.0,57.99452672247263,6 +BestFit-PN,44.0,55.99645846748229,6 +BestFit-PN,46.0,53.98792659368963,6 +BestFit-PN,48.0,51.998390212491955,6 +BestFit-PN,50.0,49.99951706374758,6 +BestFit-PN,52.0,47.98921442369607,6 +BestFit-PN,54.0,45.99726336123631,6 +BestFit-PN,56.0,43.99388280746941,6 +BestFit-PN,58.0,41.99919510624597,6 +BestFit-PN,60.0,39.99339987121699,6 +BestFit-PN,62.0,37.995492594977456,6 +BestFit-PN,64.0,35.984707018673525,6 +BestFit-PN,66.0,33.9871216999356,6 +BestFit-PN,68.0,31.9871216999356,6 +BestFit-PN,70.0,29.984063103670305,6 +BestFit-PN,72.0,27.993077913715382,6 +BestFit-PN,74.0,25.99420476497102,6 +BestFit-PN,76.0,23.993721828718602,6 +BestFit-PN,78.0,21.998712169993556,6 +BestFit-PN,80.0,19.98116548615582,6 +BestFit-PN,82.0,17.996458467482285,6 +BestFit-PN,84.0,15.996780424983895,6 +BestFit-PN,86.0,13.996136509980673,6 +BestFit-PN,88.0,11.998229233741139,6 +BestFit-PN,90.0,9.990019317450088,6 +BestFit-PN,92.0,7.989375402446869,6 +BestFit-PN,94.0,6.042981326464898,6 +BestFit-PN,96.0,6.019639407598189,6 +BestFit-PN,98.0,5.9888924661944545,6 +BestFit-PN,100.0,5.9734385061171835,6 +BestFit-PN,102.0,5.946233097231158,6 +BestFit-PN,104.0,5.9344816484224,6 +BestFit-PN,106.0,5.931905988409523,6 +BestFit-PN,108.0,5.924179008370888,6 +BestFit-PN,110.0,5.913876368319373,6 +BestFit-PN,112.0,5.892627173213129,6 +BestFit-PN,114.0,5.880553766902762,6 +BestFit-PN,116.0,5.872826786864127,6 +BestFit-PN,118.0,5.861719253058591,6 +BestFit-PN,120.0,5.84127495170637,6 +BestFit-PN,2.0,97.99533161622666,7 +BestFit-PN,4.0,95.99372182871862,7 +BestFit-PN,6.0,93.99951706374759,7 +BestFit-PN,8.0,91.99195106245975,7 +BestFit-PN,10.0,89.99275595621378,7 +BestFit-PN,12.0,87.99806825499034,7 +BestFit-PN,14.0,85.98760463618802,7 +BestFit-PN,16.0,83.9938828074694,7 +BestFit-PN,18.0,81.98518995492596,7 +BestFit-PN,20.0,79.99549259497746,7 +BestFit-PN,22.0,77.99613650998069,7 +BestFit-PN,24.0,75.98969735994848,7 +BestFit-PN,26.0,73.98857050869285,7 +BestFit-PN,28.0,71.98567289117837,7 +BestFit-PN,30.0,69.99549259497746,7 +BestFit-PN,32.0,67.9966194462331,7 +BestFit-PN,34.0,65.99613650998069,7 +BestFit-PN,36.0,63.977945911139734,7 +BestFit-PN,38.0,61.98921442369607,7 +BestFit-PN,40.0,59.998551191242754,7 +BestFit-PN,42.0,57.99356084996781,7 +BestFit-PN,44.0,55.98615582743077,7 +BestFit-PN,46.0,53.96522858982614,7 +BestFit-PN,48.0,51.94993560849967,7 +BestFit-PN,50.0,49.9869607211848,7 +BestFit-PN,52.0,47.984546039922726,7 +BestFit-PN,54.0,45.97311654861557,7 +BestFit-PN,56.0,43.997746297488725,7 +BestFit-PN,58.0,41.99018029620089,7 +BestFit-PN,60.0,39.99887314874436,7 +BestFit-PN,62.0,37.99935608499677,7 +BestFit-PN,64.0,35.99822923374114,7 +BestFit-PN,66.0,33.99420476497102,7 +BestFit-PN,68.0,31.989697359948483,7 +BestFit-PN,70.0,29.98663876368319,7 +BestFit-PN,72.0,27.99195106245975,7 +BestFit-PN,74.0,25.996136509980676,7 +BestFit-PN,76.0,23.999839021249194,7 +BestFit-PN,78.0,21.99259497746297,7 +BestFit-PN,80.0,19.98567289117836,7 +BestFit-PN,82.0,17.98406310367031,7 +BestFit-PN,84.0,15.984707018673527,7 +BestFit-PN,86.0,13.997585318737924,7 +BestFit-PN,88.0,11.987604636188017,7 +BestFit-PN,90.0,9.984707018673527,7 +BestFit-PN,92.0,7.929169349645838,7 +BestFit-PN,94.0,6.706857694784279,7 +BestFit-PN,96.0,6.672408242112033,7 +BestFit-PN,98.0,6.638441725692202,7 +BestFit-PN,100.0,6.620412105602054,7 +BestFit-PN,102.0,6.609304571796515,7 +BestFit-PN,104.0,6.591274951706367,7 +BestFit-PN,106.0,6.58177720540888,7 +BestFit-PN,108.0,6.565518351577586,7 +BestFit-PN,110.0,6.562942691564707,7 +BestFit-PN,112.0,6.558596265292977,7 +BestFit-PN,114.0,6.55344494526722,7 +BestFit-PN,116.0,6.538795878943973,7 +BestFit-PN,118.0,6.525112685125557,7 +BestFit-PN,120.0,6.518190598840948,7 +BestFit-PN,2.0,97.98760463618802,8 +BestFit-PN,4.0,95.98792659368965,8 +BestFit-PN,6.0,93.98969735994848,8 +BestFit-PN,8.0,91.99500965872505,8 +BestFit-PN,10.0,89.99130714745654,8 +BestFit-PN,12.0,87.98502897617514,8 +BestFit-PN,14.0,85.99339987121701,8 +BestFit-PN,16.0,83.99597553122987,8 +BestFit-PN,18.0,81.99855119124275,8 +BestFit-PN,20.0,79.9967804249839,8 +BestFit-PN,22.0,77.99629748873149,8 +BestFit-PN,24.0,75.9905022537025,8 +BestFit-PN,26.0,73.99758531873792,8 +BestFit-PN,28.0,71.91870573084354,8 +BestFit-PN,30.0,69.99130714745652,8 +BestFit-PN,32.0,67.99066323245331,8 +BestFit-PN,34.0,65.99839021249194,8 +BestFit-PN,36.0,63.9935608499678,8 +BestFit-PN,38.0,61.98551191242756,8 +BestFit-PN,40.0,59.9840631036703,8 +BestFit-PN,42.0,57.988248551191234,8 +BestFit-PN,44.0,55.99951706374758,8 +BestFit-PN,46.0,53.92627173213135,8 +BestFit-PN,48.0,51.98873148744365,8 +BestFit-PN,50.0,49.879748873148735,8 +BestFit-PN,52.0,47.9937218287186,8 +BestFit-PN,54.0,45.98744365743722,8 +BestFit-PN,56.0,43.985833869929166,8 +BestFit-PN,58.0,41.99758531873792,8 +BestFit-PN,60.0,39.99742433998711,8 +BestFit-PN,62.0,37.99935608499677,8 +BestFit-PN,64.0,35.99822923374114,8 +BestFit-PN,66.0,33.98438506117192,8 +BestFit-PN,68.0,31.990502253702502,8 +BestFit-PN,70.0,29.998873148744355,8 +BestFit-PN,72.0,27.993077913715382,8 +BestFit-PN,74.0,25.993238892466188,8 +BestFit-PN,76.0,23.997907276239523,8 +BestFit-PN,78.0,21.99951706374757,8 +BestFit-PN,80.0,19.999839021249183,8 +BestFit-PN,82.0,17.973116548615568,8 +BestFit-PN,84.0,15.988731487443644,8 +BestFit-PN,86.0,13.990663232453299,8 +BestFit-PN,88.0,11.988409529942032,8 +BestFit-PN,90.0,9.997585318737908,8 +BestFit-PN,92.0,7.985833869929146,8 +BestFit-PN,94.0,6.123309723116526,8 +BestFit-PN,96.0,6.104636188023158,8 +BestFit-PN,98.0,6.102865421764305,8 +BestFit-PN,100.0,6.0782356728911555,8 +BestFit-PN,102.0,6.060367031551812,8 +BestFit-PN,104.0,6.03493238892464,8 +BestFit-PN,106.0,6.0280103026400305,8 +BestFit-PN,108.0,6.023663876368297,8 +BestFit-PN,110.0,6.017707662588516,8 +BestFit-PN,112.0,6.010785576303908,8 +BestFit-PN,114.0,6.00563425627815,8 +BestFit-PN,116.0,6.000482936252395,8 +BestFit-PN,118.0,5.984385061171905,8 +BestFit-PN,120.0,5.979233741146149,8 +BestFit-PN,2.0,97.98486799742435,9 +BestFit-PN,4.0,95.99629748873149,9 +BestFit-PN,6.0,93.98470701867353,9 +BestFit-PN,8.0,91.98969735994848,9 +BestFit-PN,10.0,89.99227301996136,9 +BestFit-PN,12.0,87.99806825499034,9 +BestFit-PN,14.0,85.98647778493238,9 +BestFit-PN,16.0,83.99919510624598,9 +BestFit-PN,18.0,81.98857050869286,9 +BestFit-PN,20.0,79.98824855119125,9 +BestFit-PN,22.0,77.98905344494527,9 +BestFit-PN,24.0,75.99871216999357,9 +BestFit-PN,26.0,73.99420476497103,9 +BestFit-PN,28.0,71.99130714745654,9 +BestFit-PN,30.0,69.98502897617513,9 +BestFit-PN,32.0,67.99774629748873,9 +BestFit-PN,34.0,65.99211204121056,9 +BestFit-PN,36.0,63.987121699935614,9 +BestFit-PN,38.0,61.901481004507396,9 +BestFit-PN,40.0,59.996297488731486,9 +BestFit-PN,42.0,57.99919510624597,9 +BestFit-PN,44.0,55.997746297488725,9 +BestFit-PN,46.0,53.99323889246619,9 +BestFit-PN,48.0,51.9771410173857,9 +BestFit-PN,50.0,49.98390212491951,9 +BestFit-PN,52.0,47.977623953638115,9 +BestFit-PN,54.0,45.98985833869928,9 +BestFit-PN,56.0,43.99388280746941,9 +BestFit-PN,58.0,41.99179008370895,9 +BestFit-PN,60.0,39.990824211204114,9 +BestFit-PN,62.0,37.9971023824855,9 +BestFit-PN,64.0,35.98808757244043,9 +BestFit-PN,66.0,33.98840952994205,9 +BestFit-PN,68.0,31.995653573728262,9 +BestFit-PN,70.0,29.984385061171913,9 +BestFit-PN,72.0,27.9969414037347,9 +BestFit-PN,74.0,25.994204764971013,9 +BestFit-PN,76.0,23.99726336123631,9 +BestFit-PN,78.0,21.993077913715382,9 +BestFit-PN,80.0,19.995975531229867,9 +BestFit-PN,82.0,17.98905344494526,9 +BestFit-PN,84.0,15.997907276239529,9 +BestFit-PN,86.0,13.995653573728259,9 +BestFit-PN,88.0,11.996619446233089,9 +BestFit-PN,90.0,9.992273019961356,9 +BestFit-PN,92.0,7.994848679974235,9 +BestFit-PN,94.0,6.307952350289751,9 +BestFit-PN,96.0,6.2813908564069445,9 +BestFit-PN,98.0,6.274951706374749,9 +BestFit-PN,100.0,6.240019317450087,9 +BestFit-PN,102.0,6.22134578235672,9 +BestFit-PN,104.0,6.212813908564062,9 +BestFit-PN,106.0,6.208467482292329,9 +BestFit-PN,108.0,6.166773985833862,9 +BestFit-PN,110.0,6.1587250482936176,9 +BestFit-PN,112.0,6.137475853187371,9 +BestFit-PN,114.0,6.135705086928517,9 +BestFit-PN,116.0,6.106728911783636,9 +BestFit-PN,118.0,6.090631036703146,9 +BestFit-PN,120.0,6.074533161622657,9 +DotProd,2.0,97.9982292337411,0 +DotProd,4.0,95.98599484867987,0 +DotProd,6.0,93.98502897617504,0 +DotProd,8.0,91.9853509336767,0 +DotProd,10.0,89.99581455247906,0 +DotProd,12.0,87.99549259497748,0 +DotProd,14.0,85.99420476497099,0 +DotProd,16.0,83.97198969735986,0 +DotProd,18.0,81.98840952994199,0 +DotProd,20.0,79.99162910495812,0 +DotProd,22.0,77.99259497746297,0 +DotProd,24.0,75.99388280746943,0 +DotProd,26.0,73.99275595621378,0 +DotProd,28.0,71.98776561493891,0 +DotProd,30.0,69.99726336123639,0 +DotProd,32.0,67.97987765614954,0 +DotProd,34.0,65.99710238248572,0 +DotProd,36.0,63.94687701223456,0 +DotProd,38.0,61.96571152607873,0 +DotProd,40.0,59.98696072118497,0 +DotProd,42.0,57.99581455247922,0 +DotProd,44.0,55.9919510624599,0 +DotProd,46.0,53.996297488731614,0 +DotProd,48.0,51.99066323245343,0 +DotProd,50.0,49.991629104958264,0 +DotProd,52.0,47.93882807469424,0 +DotProd,54.0,45.9898583386994,0 +DotProd,56.0,43.98406310367042,0 +DotProd,58.0,41.988731487443765,0 +DotProd,60.0,39.98921442369617,0 +DotProd,62.0,37.99436574372192,0 +DotProd,64.0,35.98873148744372,0 +DotProd,66.0,33.99565357372832,0 +DotProd,68.0,31.995331616226707,0 +DotProd,70.0,29.999517063747632,0 +DotProd,72.0,27.995653573728312,0 +DotProd,74.0,25.962330972311705,0 +DotProd,76.0,23.987282678686466,0 +DotProd,78.0,21.990663232453368,0 +DotProd,80.0,19.985511912427615,0 +DotProd,82.0,17.991307147456595,0 +DotProd,84.0,15.92949130714752,0 +DotProd,86.0,13.997102382485558,0 +DotProd,88.0,11.985672891178385,0 +DotProd,90.0,10.355280103026404,0 +DotProd,92.0,10.333708950418549,0 +DotProd,94.0,10.308113329040573,0 +DotProd,96.0,10.302479072762402,0 +DotProd,98.0,10.294752092723767,0 +DotProd,100.0,10.276078557630399,0 +DotProd,102.0,10.272698003863495,0 +DotProd,104.0,10.265775917578884,0 +DotProd,106.0,10.247102382485517,0 +DotProd,108.0,10.241146168705738,0 +DotProd,110.0,10.229555698647783,0 +DotProd,112.0,10.209916291049586,0 +DotProd,114.0,10.207340631036708,0 +DotProd,116.0,10.18351577591758,0 +DotProd,118.0,10.178364455891824,0 +DotProd,120.0,10.159368963296847,0 +DotProd,2.0,97.98921442369604,1 +DotProd,4.0,95.99291693496447,1 +DotProd,6.0,93.9867997424339,1 +DotProd,8.0,91.97488731487435,1 +DotProd,10.0,89.99034127495166,1 +DotProd,12.0,87.99758531873792,1 +DotProd,14.0,85.99597553122989,1 +DotProd,16.0,83.98824855119112,1 +DotProd,18.0,81.98985833869915,1 +DotProd,20.0,79.99661944623298,1 +DotProd,22.0,77.98728267868633,1 +DotProd,24.0,75.99597553122982,1 +DotProd,26.0,73.99597553122985,1 +DotProd,28.0,71.98824855119126,1 +DotProd,30.0,69.99227301996146,1 +DotProd,32.0,67.99001931745026,1 +DotProd,34.0,65.99855119124292,1 +DotProd,36.0,63.998068254990514,1 +DotProd,38.0,61.98438506117208,1 +DotProd,40.0,59.985672891178496,1 +DotProd,42.0,57.990019317450226,1 +DotProd,44.0,55.98953638119782,1 +DotProd,46.0,53.99758531873806,1 +DotProd,48.0,51.9958145524792,1 +DotProd,50.0,49.89649066323257,1 +DotProd,52.0,47.998712169993674,1 +DotProd,54.0,45.9898583386994,1 +DotProd,56.0,43.99001931745019,1 +DotProd,58.0,41.997263361236406,1 +DotProd,60.0,39.99179008370904,1 +DotProd,62.0,37.995492594977556,1 +DotProd,64.0,35.99935608499685,1 +DotProd,66.0,33.99903412749522,1 +DotProd,68.0,31.991146168705768,1 +DotProd,70.0,29.99758531873797,1 +DotProd,72.0,27.98792659368968,1 +DotProd,74.0,25.998873148744405,1 +DotProd,76.0,23.99436574372187,1 +DotProd,78.0,21.99372182871865,1 +DotProd,80.0,19.986316806181627,1 +DotProd,82.0,17.993399871217047,1 +DotProd,84.0,15.987765614938876,1 +DotProd,86.0,13.993399871217047,1 +DotProd,88.0,11.999034127495191,1 +DotProd,90.0,10.213940759819717,1 +DotProd,92.0,10.175305859626544,1 +DotProd,94.0,10.166613007083079,1 +DotProd,96.0,10.140212491951077,1 +DotProd,98.0,10.13506117192532,1 +DotProd,100.0,10.125563425627835,1 +DotProd,102.0,10.093367675466855,1 +DotProd,104.0,10.082260141661315,1 +DotProd,106.0,10.076303927881538,1 +DotProd,108.0,10.058435286542194,1 +DotProd,110.0,10.058435286542194,1 +DotProd,112.0,10.03074694140375,1 +DotProd,114.0,10.008692852543485,1 +DotProd,116.0,9.971345782356748,1 +DotProd,118.0,9.954121056020625,1 +DotProd,120.0,9.92514488087575,1 +DotProd,2.0,97.93206696716035,2 +DotProd,4.0,95.99517063747581,2 +DotProd,6.0,93.9888924661944,2 +DotProd,8.0,91.98712169993559,2 +DotProd,10.0,89.98712169993559,2 +DotProd,12.0,87.99951706374752,2 +DotProd,14.0,85.99565357372823,2 +DotProd,16.0,83.98712169993553,2 +DotProd,18.0,81.99629748873139,2 +DotProd,20.0,79.98873148744356,2 +DotProd,22.0,77.99356084996774,2 +DotProd,24.0,75.99726336123622,2 +DotProd,26.0,73.99710238248547,2 +DotProd,28.0,71.99935608499679,2 +DotProd,30.0,69.99372182871866,2 +DotProd,32.0,67.98857050869293,2 +DotProd,34.0,65.99420476497113,2 +DotProd,36.0,63.98309723116559,2 +DotProd,38.0,61.997585318738025,2 +DotProd,40.0,59.98905344494536,2 +DotProd,42.0,57.99195106245983,2 +DotProd,44.0,55.99661944623319,2 +DotProd,46.0,53.992433998712244,2 +DotProd,48.0,51.9872826786865,2 +DotProd,50.0,49.99645846748238,2 +DotProd,52.0,47.99533161622673,2 +DotProd,54.0,45.990663232453386,2 +DotProd,56.0,43.990824211204185,2 +DotProd,58.0,41.995492594977534,2 +DotProd,60.0,39.99404378622027,2 +DotProd,62.0,37.995009658725095,2 +DotProd,64.0,35.99452672247268,2 +DotProd,66.0,33.993721828718655,2 +DotProd,68.0,31.99356084996785,2 +DotProd,70.0,29.99935608499683,2 +DotProd,72.0,27.991790083709006,2 +DotProd,74.0,25.998551191242807,2 +DotProd,76.0,23.99919510624603,2 +DotProd,78.0,21.995331616226714,2 +DotProd,80.0,19.99307791371545,2 +DotProd,82.0,17.984063103670373,2 +DotProd,84.0,15.99179008370901,2 +DotProd,86.0,13.995492594977513,2 +DotProd,88.0,11.997907276239568,2 +DotProd,90.0,10.777527366387666,2 +DotProd,92.0,10.7654539600773,2 +DotProd,94.0,10.74742433998715,2 +DotProd,96.0,10.726175144880905,2 +DotProd,98.0,10.710077269800413,2 +DotProd,100.0,10.694623309723141,2 +DotProd,102.0,10.68077913715392,2 +DotProd,104.0,10.656954282034798,2 +DotProd,106.0,10.649227301996161,2 +DotProd,108.0,10.649227301996161,2 +DotProd,110.0,10.636349001931768,2 +DotProd,112.0,10.623470701867376,2 +DotProd,114.0,10.580972311654884,2 +DotProd,116.0,10.534127495170662,2 +DotProd,118.0,10.534127495170662,2 +DotProd,120.0,10.526400515132025,2 +DotProd,2.0,97.99694140373472,3 +DotProd,4.0,95.99388280746939,3 +DotProd,6.0,93.99919510624596,3 +DotProd,8.0,91.99661944623307,3 +DotProd,10.0,89.99661944623311,3 +DotProd,12.0,87.99146812620738,3 +DotProd,14.0,85.98921442369611,3 +DotProd,16.0,83.98470701867348,3 +DotProd,18.0,81.9848679974243,3 +DotProd,20.0,79.98583386992914,3 +DotProd,22.0,77.99066323245324,3 +DotProd,24.0,75.99871216999348,3 +DotProd,26.0,73.99146812620731,3 +DotProd,28.0,71.99291693496455,3 +DotProd,30.0,69.99517063747585,3 +DotProd,32.0,67.99903412749525,3 +DotProd,34.0,65.98551191242768,3 +DotProd,36.0,63.99597553122997,3 +DotProd,38.0,61.987765614938915,3 +DotProd,40.0,59.9806825499035,3 +DotProd,42.0,57.99629748873157,3 +DotProd,44.0,55.9905022537026,3 +DotProd,46.0,53.99066323245339,3 +DotProd,48.0,51.998712169993645,3 +DotProd,50.0,49.989536381197766,3 +DotProd,52.0,47.98551191242764,3 +DotProd,54.0,45.98535093367684,3 +DotProd,56.0,43.99790727623964,3 +DotProd,58.0,41.98631680618168,3 +DotProd,60.0,39.98406310367041,3 +DotProd,62.0,37.987765614938915,3 +DotProd,64.0,35.98438506117201,3 +DotProd,66.0,33.97392144236968,3 +DotProd,68.0,31.997907276239605,3 +DotProd,70.0,29.99533161622673,3 +DotProd,72.0,27.9879265936897,3 +DotProd,74.0,25.989697359948554,3 +DotProd,76.0,23.998551191242825,3 +DotProd,78.0,21.998068254990415,3 +DotProd,80.0,19.999195106246052,3 +DotProd,82.0,17.992433998712244,3 +DotProd,84.0,15.999195106246052,3 +DotProd,86.0,13.995170637475917,3 +DotProd,88.0,11.995653573728294,3 +DotProd,90.0,10.43158403090794,3 +DotProd,92.0,10.417739858338718,3 +DotProd,94.0,10.387958789439814,3 +DotProd,96.0,10.364938828074713,3 +DotProd,98.0,10.346265292981348,3 +DotProd,100.0,10.339343206696737,3 +DotProd,102.0,10.334191886670983,3 +DotProd,104.0,10.329040566645224,3 +DotProd,106.0,10.250000000000025,3 +DotProd,108.0,10.244043786220242,3 +DotProd,110.0,10.223599484868021,3 +DotProd,112.0,10.216677398583412,3 +DotProd,114.0,10.191081777205431,3 +DotProd,116.0,10.173857050869309,3 +DotProd,118.0,10.150837089504208,3 +DotProd,120.0,10.11864133934323,3 +DotProd,2.0,97.9966194462331,4 +DotProd,4.0,95.9962974887314,4 +DotProd,6.0,93.99983902124912,4 +DotProd,8.0,91.99710238248542,4 +DotProd,10.0,89.99726336123625,4 +DotProd,12.0,87.98792659368964,4 +DotProd,14.0,85.99323889246621,4 +DotProd,16.0,83.99227301996127,4 +DotProd,18.0,81.99533161622648,4 +DotProd,20.0,79.99034127495155,4 +DotProd,22.0,77.99565357372812,4 +DotProd,24.0,75.99420476497093,4 +DotProd,26.0,73.93947198969727,4 +DotProd,28.0,71.99710238248545,4 +DotProd,30.0,69.99452672247264,4 +DotProd,32.0,67.90534449452686,4 +DotProd,34.0,65.99710238248568,4 +DotProd,36.0,63.98358016741806,4 +DotProd,38.0,61.995170637476015,4 +DotProd,40.0,59.98889246619461,4 +DotProd,42.0,57.997102382485664,4 +DotProd,44.0,55.99629748873164,4 +DotProd,46.0,53.998873148744494,4 +DotProd,48.0,51.9987121699937,4 +DotProd,50.0,49.99323889246632,4 +DotProd,52.0,47.99452672247275,4 +DotProd,54.0,45.99356084996791,4 +DotProd,56.0,43.994848679974346,4 +DotProd,58.0,41.98953638119777,4 +DotProd,60.0,39.99082421120422,4 +DotProd,62.0,37.99114616870581,4 +DotProd,64.0,35.994848679974325,4 +DotProd,66.0,33.99146812620738,4 +DotProd,68.0,31.988892466194496,4 +DotProd,70.0,29.997424339987166,4 +DotProd,72.0,27.99018029620094,4 +DotProd,74.0,25.999356084996823,4 +DotProd,76.0,23.995331616226704,4 +DotProd,78.0,21.99694140373475,4 +DotProd,80.0,19.992916934964626,4 +DotProd,82.0,18.000000000000053,4 +DotProd,84.0,15.985833869929223,4 +DotProd,86.0,13.990663232453365,4 +DotProd,88.0,11.984707018673568,4 +DotProd,90.0,10.137797810689015,4 +DotProd,92.0,10.122987765614964,4 +DotProd,94.0,10.094011590470082,4 +DotProd,96.0,10.083708950418567,4 +DotProd,98.0,10.049581455247928,4 +DotProd,100.0,10.031551835157783,4 +DotProd,102.0,10.004185447520948,4 +DotProd,104.0,9.986316806181604,4 +DotProd,106.0,9.981165486155849,4 +DotProd,108.0,9.947842884739234,4 +DotProd,110.0,9.938345138441745,4 +DotProd,112.0,9.935769478428869,4 +DotProd,114.0,9.899227301996158,4 +DotProd,116.0,9.865743721828737,4 +DotProd,118.0,9.857211848036078,4 +DotProd,120.0,9.841757887958808,4 +DotProd,2.0,97.98164842240823,5 +DotProd,4.0,95.98905344494523,5 +DotProd,6.0,93.99098518995487,5 +DotProd,8.0,91.99581455247905,5 +DotProd,10.0,89.98470701867356,5 +DotProd,12.0,87.99919510624602,5 +DotProd,14.0,85.99661944623317,5 +DotProd,16.0,83.99887314874441,5 +DotProd,18.0,81.99034127495169,5 +DotProd,20.0,79.99533161622664,5 +DotProd,22.0,77.9943657437218,5 +DotProd,24.0,75.99468770122341,5 +DotProd,26.0,73.99565357372828,5 +DotProd,28.0,71.99983902124923,5 +DotProd,30.0,69.99001931745015,5 +DotProd,32.0,67.99468770122354,5 +DotProd,34.0,65.99034127495187,5 +DotProd,36.0,63.9946877012236,5 +DotProd,38.0,61.99339987121715,5 +DotProd,40.0,59.99130714745667,5 +DotProd,42.0,57.99098518995505,5 +DotProd,44.0,55.99356084996793,5 +DotProd,46.0,53.994687701223555,5 +DotProd,48.0,51.92289117836456,5 +DotProd,50.0,49.98857050869295,5 +DotProd,52.0,47.999839021249294,5 +DotProd,54.0,45.92305215711535,5 +DotProd,56.0,43.99806825499042,5 +DotProd,58.0,41.997907276239616,5 +DotProd,60.0,39.99018029620098,5 +DotProd,62.0,37.94011590470065,5 +DotProd,64.0,35.98792659368968,5 +DotProd,66.0,33.99323889246622,5 +DotProd,68.0,31.99404378622025,5 +DotProd,70.0,29.99356084996783,5 +DotProd,72.0,27.997424339987155,5 +DotProd,74.0,25.9922730199614,5 +DotProd,76.0,23.98985833869932,5 +DotProd,78.0,21.915164198325858,5 +DotProd,80.0,19.994204764971062,5 +DotProd,82.0,17.999839021249244,5 +DotProd,84.0,15.991468126207387,5 +DotProd,86.0,13.984546039922762,5 +DotProd,88.0,11.991307147456553,5 +DotProd,90.0,10.542176432710896,5 +DotProd,92.0,10.521732131358675,5 +DotProd,94.0,10.514810045074062,5 +DotProd,96.0,10.490985189954937,5 +DotProd,98.0,10.488409529942059,5 +DotProd,100.0,10.475531229877669,5 +DotProd,102.0,10.457662588538327,5 +DotProd,104.0,10.45589182227947,5 +DotProd,106.0,10.453316162266594,5 +DotProd,108.0,10.44719896973601,5 +DotProd,110.0,10.411139729555712,5 +DotProd,112.0,10.403412749517079,5 +DotProd,114.0,10.37186091435932,5 +DotProd,116.0,10.364938828074708,5 +DotProd,118.0,10.358016741790099,5 +DotProd,120.0,10.34851899549261,5 +DotProd,2.0,97.98824855119122,6 +DotProd,4.0,95.98551191242748,6 +DotProd,6.0,93.99227301996133,6 +DotProd,8.0,91.99645846748223,6 +DotProd,10.0,89.94510624597551,6 +DotProd,12.0,87.99388280746942,6 +DotProd,14.0,85.99372182871862,6 +DotProd,16.0,83.99565357372823,6 +DotProd,18.0,81.98599484867984,6 +DotProd,20.0,79.99774629748862,6 +DotProd,22.0,77.98889246619434,6 +DotProd,24.0,75.9935608499677,6 +DotProd,26.0,73.99597553122976,6 +DotProd,28.0,71.98422408242104,6 +DotProd,30.0,69.98180940115898,6 +DotProd,32.0,67.99227301996136,6 +DotProd,34.0,65.99339987121711,6 +DotProd,36.0,63.99517063747594,6 +DotProd,38.0,61.99500965872513,6 +DotProd,40.0,59.983902124919595,6 +DotProd,42.0,57.99452672247271,6 +DotProd,44.0,55.99645846748237,6 +DotProd,46.0,53.98792659368969,6 +DotProd,48.0,51.99839021249202,6 +DotProd,50.0,49.99951706374765,6 +DotProd,52.0,47.98921442369615,6 +DotProd,54.0,45.99726336123639,6 +DotProd,56.0,43.99388280746948,6 +DotProd,58.0,41.99919510624605,6 +DotProd,60.0,39.993399871217065,6 +DotProd,62.0,37.99549259497753,6 +DotProd,64.0,35.9847070186736,6 +DotProd,66.0,33.98712169993566,6 +DotProd,68.0,31.987121699935656,6 +DotProd,70.0,29.984063103670366,6 +DotProd,72.0,27.993077913715442,6 +DotProd,74.0,25.994204764971073,6 +DotProd,76.0,23.993721828718662,6 +DotProd,78.0,21.99871216999361,6 +DotProd,80.0,19.981165486155874,6 +DotProd,82.0,17.996458467482345,6 +DotProd,84.0,15.996780424983953,6 +DotProd,86.0,13.996136509980728,6 +DotProd,88.0,11.998229233741169,6 +DotProd,90.0,10.090148100450756,6 +DotProd,92.0,10.060849967804266,6 +DotProd,94.0,10.060849967804266,6 +DotProd,96.0,10.059079201545412,6 +DotProd,98.0,10.031873792659384,6 +DotProd,100.0,10.016419832582114,6 +DotProd,102.0,9.989214423696088,6 +DotProd,104.0,9.977462974887331,6 +DotProd,106.0,9.974887314874453,6 +DotProd,108.0,9.967160334835818,6 +DotProd,110.0,9.956857694784306,6 +DotProd,112.0,9.93560849967806,6 +DotProd,114.0,9.923535093367692,6 +DotProd,116.0,9.915808113329055,6 +DotProd,118.0,9.904700579523517,6 +DotProd,120.0,9.884256278171295,6 +DotProd,2.0,97.99533161622665,7 +DotProd,4.0,95.99372182871848,7 +DotProd,6.0,93.99951706374749,7 +DotProd,8.0,91.99195106245966,7 +DotProd,10.0,89.99275595621374,7 +DotProd,12.0,87.99806825499033,7 +DotProd,14.0,85.98760463618805,7 +DotProd,16.0,83.9938828074694,7 +DotProd,18.0,81.98518995492587,7 +DotProd,20.0,79.99549259497738,7 +DotProd,22.0,77.9961365099806,7 +DotProd,24.0,75.98969735994844,7 +DotProd,26.0,73.9885705086928,7 +DotProd,28.0,71.98567289117833,7 +DotProd,30.0,69.99549259497748,7 +DotProd,32.0,67.99661944623323,7 +DotProd,34.0,65.99613650998083,7 +DotProd,36.0,63.97794591113988,7 +DotProd,38.0,61.98921442369622,7 +DotProd,40.0,59.99855119124289,7 +DotProd,42.0,57.99356084996794,7 +DotProd,44.0,55.98615582743089,7 +DotProd,46.0,53.96522858982627,7 +DotProd,48.0,51.949935608499786,7 +DotProd,50.0,49.986960721184914,7 +DotProd,52.0,47.984546039922826,7 +DotProd,54.0,45.97311654861569,7 +DotProd,56.0,43.99774629748883,7 +DotProd,58.0,41.99018029620098,7 +DotProd,60.0,39.998873148744444,7 +DotProd,62.0,37.99935608499684,7 +DotProd,64.0,35.998229233741206,7 +DotProd,66.0,33.994204764971066,7 +DotProd,68.0,31.98969735994851,7 +DotProd,70.0,29.98663876368322,7 +DotProd,72.0,27.99195106245978,7 +DotProd,74.0,25.996136509980715,7 +DotProd,76.0,23.99983902124923,7 +DotProd,78.0,21.99259497746301,7 +DotProd,80.0,19.985672891178403,7 +DotProd,82.0,17.98406310367035,7 +DotProd,84.0,15.984707018673575,7 +DotProd,86.0,13.997585318737963,7 +DotProd,88.0,11.987604636188042,7 +DotProd,90.0,10.499195106245994,7 +DotProd,92.0,10.467321313586627,7 +DotProd,94.0,10.460399227302016,7 +DotProd,96.0,10.43319381841599,7 +DotProd,98.0,10.399227301996158,7 +DotProd,100.0,10.38119768190601,7 +DotProd,102.0,10.370090148100473,7 +DotProd,104.0,10.352060528010323,7 +DotProd,106.0,10.342562781712834,7 +DotProd,108.0,10.326303927881538,7 +DotProd,110.0,10.32372826786866,7 +DotProd,112.0,10.319381841596927,7 +DotProd,114.0,10.31423052157117,7 +DotProd,116.0,10.299581455247921,7 +DotProd,118.0,10.285898261429507,7 +DotProd,120.0,10.278976175144896,7 +DotProd,2.0,97.98760463618802,8 +DotProd,4.0,95.98792659368958,8 +DotProd,6.0,93.98969735994844,8 +DotProd,8.0,91.995009658725,8 +DotProd,10.0,89.99130714745652,8 +DotProd,12.0,87.98502897617514,8 +DotProd,14.0,85.99339987121706,8 +DotProd,16.0,83.99597553122987,8 +DotProd,18.0,81.9985511912427,8 +DotProd,20.0,79.99678042498387,8 +DotProd,22.0,77.99629748873144,8 +DotProd,24.0,75.9905022537025,8 +DotProd,26.0,73.99758531873793,8 +DotProd,28.0,71.91870573084354,8 +DotProd,30.0,69.99130714745655,8 +DotProd,32.0,67.99066323245336,8 +DotProd,34.0,65.9983902124921,8 +DotProd,36.0,63.99356084996791,8 +DotProd,38.0,61.98551191242767,8 +DotProd,40.0,59.984063103670415,8 +DotProd,42.0,57.988248551191354,8 +DotProd,44.0,55.999517063747696,8 +DotProd,46.0,53.92627173213147,8 +DotProd,48.0,51.988731487443744,8 +DotProd,50.0,49.87974887314883,8 +DotProd,52.0,47.99372182871869,8 +DotProd,54.0,45.9874436574373,8 +DotProd,56.0,43.985833869929245,8 +DotProd,58.0,41.99758531873799,8 +DotProd,60.0,39.997424339987184,8 +DotProd,62.0,37.99935608499684,8 +DotProd,64.0,35.99822923374121,8 +DotProd,66.0,33.984385061171984,8 +DotProd,68.0,31.99050225370255,8 +DotProd,70.0,29.99887314874441,8 +DotProd,72.0,27.993077913715435,8 +DotProd,74.0,25.99323889246624,8 +DotProd,76.0,23.997907276239587,8 +DotProd,78.0,21.999517063747632,8 +DotProd,80.0,19.999839021249237,8 +DotProd,82.0,17.973116548615632,8 +DotProd,84.0,15.988731487443705,8 +DotProd,86.0,13.990663232453372,8 +DotProd,88.0,11.988409529942071,8 +DotProd,90.0,10.056503541532527,8 +DotProd,92.0,10.045556986477793,8 +DotProd,94.0,10.018995492594984,8 +DotProd,96.0,10.018995492594984,8 +DotProd,98.0,10.017224726336131,8 +DotProd,100.0,9.992594977462982,8 +DotProd,102.0,9.974726336123638,8 +DotProd,104.0,9.949291693496464,8 +DotProd,106.0,9.926271732131365,8 +DotProd,108.0,9.921925305859633,8 +DotProd,110.0,9.915969092079854,8 +DotProd,112.0,9.892949130714753,8 +DotProd,114.0,9.887797810688994,8 +DotProd,116.0,9.882646490663237,8 +DotProd,118.0,9.866548615582749,8 +DotProd,120.0,9.861397295556992,8 +DotProd,2.0,97.98486799742436,9 +DotProd,4.0,95.99629748873143,9 +DotProd,6.0,93.98470701867346,9 +DotProd,8.0,91.98969735994842,9 +DotProd,10.0,89.9922730199613,9 +DotProd,12.0,87.99806825499033,9 +DotProd,14.0,85.98647778493242,9 +DotProd,16.0,83.99919510624592,9 +DotProd,18.0,81.98857050869273,9 +DotProd,20.0,79.98824855119115,9 +DotProd,22.0,77.9890534449452,9 +DotProd,24.0,75.9987121699935,9 +DotProd,26.0,73.994204764971,9 +DotProd,28.0,71.9913071474565,9 +DotProd,30.0,69.98502897617517,9 +DotProd,32.0,67.99774629748883,9 +DotProd,34.0,65.99211204121072,9 +DotProd,36.0,63.987121699935734,9 +DotProd,38.0,61.90148100450753,9 +DotProd,40.0,59.9962974887316,9 +DotProd,42.0,57.99919510624609,9 +DotProd,44.0,55.99774629748884,9 +DotProd,46.0,53.9932388924663,9 +DotProd,48.0,51.97714101738582,9 +DotProd,50.0,49.983902124919624,9 +DotProd,52.0,47.97762395363822,9 +DotProd,54.0,45.98985833869939,9 +DotProd,56.0,43.99388280746951,9 +DotProd,58.0,41.99179008370904,9 +DotProd,60.0,39.990824211204206,9 +DotProd,62.0,37.99710238248559,9 +DotProd,64.0,35.98808757244053,9 +DotProd,66.0,33.98840952994211,9 +DotProd,68.0,31.995653573728323,9 +DotProd,70.0,29.98438506117198,9 +DotProd,72.0,27.996941403734766,9 +DotProd,74.0,25.994204764971073,9 +DotProd,76.0,23.997263361236364,9 +DotProd,78.0,21.993077913715435,9 +DotProd,80.0,19.995975531229924,9 +DotProd,82.0,17.98905344494532,9 +DotProd,84.0,15.997907276239594,9 +DotProd,86.0,13.995653573728314,9 +DotProd,88.0,11.99661944623312,9 +DotProd,90.0,10.693335479716701,9 +DotProd,92.0,10.6373148744366,9 +DotProd,94.0,10.624436574372206,9 +DotProd,96.0,10.603026400515157,9 +DotProd,98.0,10.59658725048296,9 +DotProd,100.0,10.5616548615583,9 +DotProd,102.0,10.542981326464927,9 +DotProd,104.0,10.53444945267227,9 +DotProd,106.0,10.530103026400537,9 +DotProd,108.0,10.488409529942066,9 +DotProd,110.0,10.480360592401825,9 +DotProd,112.0,10.459111397295578,9 +DotProd,114.0,10.457340631036724,9 +DotProd,116.0,10.428364455891842,9 +DotProd,118.0,10.412266580811352,9 +DotProd,120.0,10.396168705730863,9 +Packing,2.0,97.99822923374113,0 +Packing,4.0,95.98599484867995,0 +Packing,6.0,93.98502897617516,0 +Packing,8.0,91.98535093367678,0 +Packing,10.0,89.99581455247912,0 +Packing,12.0,87.99549259497749,0 +Packing,14.0,85.99420476497095,0 +Packing,16.0,83.97198969735982,0 +Packing,18.0,81.98840952994193,0 +Packing,20.0,79.99162910495806,0 +Packing,22.0,77.99259497746289,0 +Packing,24.0,75.99388280746939,0 +Packing,26.0,73.99275595621376,0 +Packing,28.0,71.98776561493885,0 +Packing,30.0,69.99726336123635,0 +Packing,32.0,67.97987765614948,0 +Packing,34.0,65.99710238248565,0 +Packing,36.0,63.94687701223454,0 +Packing,38.0,61.96571152607869,0 +Packing,40.0,59.98696072118492,0 +Packing,42.0,57.99581455247919,0 +Packing,44.0,55.99195106245987,0 +Packing,46.0,53.99629748873159,0 +Packing,48.0,51.990663232453414,0 +Packing,50.0,49.991629104958236,0 +Packing,52.0,47.938828074694214,0 +Packing,54.0,45.98985833869937,0 +Packing,56.0,43.984063103670366,0 +Packing,58.0,41.98873148744371,0 +Packing,60.0,39.98921442369612,0 +Packing,62.0,37.99436574372187,0 +Packing,64.0,35.988731487443694,0 +Packing,66.0,33.995653573728305,0 +Packing,68.0,31.995331616226675,0 +Packing,70.0,29.999517063747604,0 +Packing,72.0,27.99565357372828,0 +Packing,74.0,25.96233097231166,0 +Packing,76.0,23.98728267868642,0 +Packing,78.0,21.99066323245332,0 +Packing,80.0,19.985511912427555,0 +Packing,82.0,17.991307147456535,0 +Packing,84.0,15.929491307147458,0 +Packing,86.0,13.997102382485501,0 +Packing,88.0,11.985672891178355,0 +Packing,90.0,9.997907276239513,0 +Packing,92.0,7.999195106245947,0 +Packing,94.0,5.98873148744363,0 +Packing,96.0,5.816162266580784,0 +Packing,98.0,5.804732775273637,0 +Packing,100.0,5.786059240180269,0 +Packing,102.0,5.782678686413365,0 +Packing,104.0,5.775756600128756,0 +Packing,106.0,5.7570830650353875,0 +Packing,108.0,5.751126851255607,0 +Packing,110.0,5.739536381197654,0 +Packing,112.0,5.719896973599457,0 +Packing,114.0,5.717321313586578,0 +Packing,116.0,5.693496458467455,0 +Packing,118.0,5.688345138441697,0 +Packing,120.0,5.669349645846721,0 +Packing,2.0,97.98921442369605,1 +Packing,4.0,95.9929169349646,1 +Packing,6.0,93.986799742434,1 +Packing,8.0,91.97488731487448,1 +Packing,10.0,89.99034127495176,1 +Packing,12.0,87.99758531873799,1 +Packing,14.0,85.99597553122987,1 +Packing,16.0,83.98824855119112,1 +Packing,18.0,81.98985833869915,1 +Packing,20.0,79.99661944623303,1 +Packing,22.0,77.98728267868633,1 +Packing,24.0,75.9959755312298,1 +Packing,26.0,73.99597553122985,1 +Packing,28.0,71.98824855119126,1 +Packing,30.0,69.99227301996137,1 +Packing,32.0,67.99001931745016,1 +Packing,34.0,65.99855119124291,1 +Packing,36.0,63.99806825499047,1 +Packing,38.0,61.98438506117202,1 +Packing,40.0,59.98567289117845,1 +Packing,42.0,57.99001931745019,1 +Packing,44.0,55.989536381197766,1 +Packing,46.0,53.997585318738,1 +Packing,48.0,51.995814552479146,1 +Packing,50.0,49.89649066323253,1 +Packing,52.0,47.998712169993624,1 +Packing,54.0,45.98985833869935,1 +Packing,56.0,43.99001931745014,1 +Packing,58.0,41.99726336123636,1 +Packing,60.0,39.99179008370899,1 +Packing,62.0,37.9954925949775,1 +Packing,64.0,35.999356084996805,1 +Packing,66.0,33.999034127495186,1 +Packing,68.0,31.991146168705743,1 +Packing,70.0,29.99758531873794,1 +Packing,72.0,27.98792659368964,1 +Packing,74.0,25.998873148744373,1 +Packing,76.0,23.994365743721836,1 +Packing,78.0,21.993721828718613,1 +Packing,80.0,19.986316806181588,1 +Packing,82.0,17.993399871217004,1 +Packing,84.0,15.987765614938828,1 +Packing,86.0,13.993399871216994,1 +Packing,88.0,11.99903412749516,1 +Packing,90.0,9.990824211204101,1 +Packing,92.0,7.99050225370249,1 +Packing,94.0,5.998551191242732,1 +Packing,96.0,5.684320669671579,1 +Packing,98.0,5.679169349645822,1 +Packing,100.0,5.669671603348334,1 +Packing,102.0,5.637475853187356,1 +Packing,104.0,5.626368319381818,1 +Packing,106.0,5.620412105602037,1 +Packing,108.0,5.602543464262694,1 +Packing,110.0,5.602543464262694,1 +Packing,112.0,5.574855119124253,1 +Packing,114.0,5.552801030263983,1 +Packing,116.0,5.515453960077248,1 +Packing,118.0,5.4982292337411245,1 +Packing,120.0,5.4692530585962436,1 +Packing,2.0,97.9320669671603,2 +Packing,4.0,95.99517063747582,2 +Packing,6.0,93.98889246619446,2 +Packing,8.0,91.98712169993564,2 +Packing,10.0,89.98712169993567,2 +Packing,12.0,87.99951706374763,2 +Packing,14.0,85.99565357372826,2 +Packing,16.0,83.98712169993554,2 +Packing,18.0,81.99629748873136,2 +Packing,20.0,79.98873148744356,2 +Packing,22.0,77.99356084996771,2 +Packing,24.0,75.99726336123622,2 +Packing,26.0,73.99710238248542,2 +Packing,28.0,71.99935608499675,2 +Packing,30.0,69.99372182871856,2 +Packing,32.0,67.98857050869293,2 +Packing,34.0,65.99420476497114,2 +Packing,36.0,63.98309723116561,2 +Packing,38.0,61.99758531873803,2 +Packing,40.0,59.98905344494537,2 +Packing,42.0,57.991951062459854,2 +Packing,44.0,55.99661944623321,2 +Packing,46.0,53.992433998712286,2 +Packing,48.0,51.98728267868651,2 +Packing,50.0,49.9964584674824,2 +Packing,52.0,47.995331616226764,2 +Packing,54.0,45.99066323245342,2 +Packing,56.0,43.99082421120419,2 +Packing,58.0,41.995492594977534,2 +Packing,60.0,39.994043786220274,2 +Packing,62.0,37.995009658725095,2 +Packing,64.0,35.99452672247266,2 +Packing,66.0,33.99372182871863,2 +Packing,68.0,31.993560849967817,2 +Packing,70.0,29.99935608499679,2 +Packing,72.0,27.991790083708963,2 +Packing,74.0,25.99855119124278,2 +Packing,76.0,23.999195106245992,2 +Packing,78.0,21.99533161622667,2 +Packing,80.0,19.993077913715393,2 +Packing,82.0,17.98406310367032,2 +Packing,84.0,15.991790083708954,2 +Packing,86.0,13.995492594977458,2 +Packing,88.0,11.99790727623953,2 +Packing,90.0,9.994848679974226,2 +Packing,92.0,7.990985189954904,2 +Packing,94.0,5.986155827430757,2 +Packing,96.0,5.863007083065013,2 +Packing,98.0,5.846909207984523,2 +Packing,100.0,5.831455247907253,2 +Packing,102.0,5.817611075338032,2 +Packing,104.0,5.793786220218908,2 +Packing,106.0,5.786059240180273,2 +Packing,108.0,5.786059240180273,2 +Packing,110.0,5.773180940115881,2 +Packing,112.0,5.760302640051489,2 +Packing,114.0,5.717804249838998,2 +Packing,116.0,5.670959433354774,2 +Packing,118.0,5.670959433354774,2 +Packing,120.0,5.663232453316139,2 +Packing,2.0,97.99694140373468,3 +Packing,4.0,95.99388280746942,3 +Packing,6.0,93.99919510624598,3 +Packing,8.0,91.99661944623314,3 +Packing,10.0,89.99661944623317,3 +Packing,12.0,87.99146812620742,3 +Packing,14.0,85.98921442369608,3 +Packing,16.0,83.98470701867345,3 +Packing,18.0,81.98486799742426,3 +Packing,20.0,79.98583386992911,3 +Packing,22.0,77.99066323245324,3 +Packing,24.0,75.99871216999354,3 +Packing,26.0,73.99146812620732,3 +Packing,28.0,71.99291693496461,3 +Packing,30.0,69.99517063747585,3 +Packing,32.0,67.99903412749526,3 +Packing,34.0,65.98551191242768,3 +Packing,36.0,63.99597553122999,3 +Packing,38.0,61.98776561493893,3 +Packing,40.0,59.9806825499035,3 +Packing,42.0,57.996297488731585,3 +Packing,44.0,55.9905022537026,3 +Packing,46.0,53.99066323245341,3 +Packing,48.0,51.998712169993645,3 +Packing,50.0,49.98953638119775,3 +Packing,52.0,47.98551191242761,3 +Packing,54.0,45.98535093367681,3 +Packing,56.0,43.99790727623959,3 +Packing,58.0,41.98631680618162,3 +Packing,60.0,39.98406310367035,3 +Packing,62.0,37.987765614938866,3 +Packing,64.0,35.984385061171956,3 +Packing,66.0,33.973921442369644,3 +Packing,68.0,31.997907276239566,3 +Packing,70.0,29.995331616226682,3 +Packing,72.0,27.987926593689654,3 +Packing,74.0,25.989697359948504,3 +Packing,76.0,23.998551191242772,3 +Packing,78.0,21.99806825499035,3 +Packing,80.0,19.999195106245985,3 +Packing,82.0,17.992433998712173,3 +Packing,84.0,15.999195106245976,3 +Packing,86.0,13.995170637475846,3 +Packing,88.0,11.995653573728255,3 +Packing,90.0,9.996780424983882,3 +Packing,92.0,7.997263361236293,3 +Packing,94.0,5.994365743721803,3 +Packing,96.0,5.8029620090147835,3 +Packing,98.0,5.784288473921416,3 +Packing,100.0,5.777366387636804,3 +Packing,102.0,5.772215067611047,3 +Packing,104.0,5.767063747585291,3 +Packing,106.0,5.736316806181558,3 +Packing,108.0,5.730360592401777,3 +Packing,110.0,5.709916291049557,3 +Packing,112.0,5.702994204764946,3 +Packing,114.0,5.693496458467457,3 +Packing,116.0,5.676271732131335,3 +Packing,118.0,5.669349645846725,3 +Packing,120.0,5.6371538956857465,3 +Packing,2.0,97.9966194462331,4 +Packing,4.0,95.99629748873149,4 +Packing,6.0,93.9998390212492,4 +Packing,8.0,91.99710238248554,4 +Packing,10.0,89.99726336123636,4 +Packing,12.0,87.9879265936897,4 +Packing,14.0,85.99323889246627,4 +Packing,16.0,83.99227301996132,4 +Packing,18.0,81.9953316162265,4 +Packing,20.0,79.99034127495158,4 +Packing,22.0,77.99565357372812,4 +Packing,24.0,75.9942047649709,4 +Packing,26.0,73.93947198969728,4 +Packing,28.0,71.99710238248544,4 +Packing,30.0,69.9945267224726,4 +Packing,32.0,67.90534449452682,4 +Packing,34.0,65.99710238248572,4 +Packing,36.0,63.98358016741808,4 +Packing,38.0,61.99517063747603,4 +Packing,40.0,59.988892466194635,4 +Packing,42.0,57.997102382485686,4 +Packing,44.0,55.99629748873165,4 +Packing,46.0,53.99887314874452,4 +Packing,48.0,51.99871216999371,4 +Packing,50.0,49.99323889246634,4 +Packing,52.0,47.99452672247277,4 +Packing,54.0,45.993560849967935,4 +Packing,56.0,43.99484867997435,4 +Packing,58.0,41.989536381197794,4 +Packing,60.0,39.99082421120423,4 +Packing,62.0,37.99114616870583,4 +Packing,64.0,35.994848679974304,4 +Packing,66.0,33.99146812620737,4 +Packing,68.0,31.988892466194496,4 +Packing,70.0,29.997424339987155,4 +Packing,72.0,27.99018029620093,4 +Packing,74.0,25.999356084996805,4 +Packing,76.0,23.995331616226682,4 +Packing,78.0,21.99694140373473,4 +Packing,80.0,19.99291693496462,4 +Packing,82.0,18.000000000000018,4 +Packing,84.0,15.985833869929186,4 +Packing,86.0,13.990663232453333,4 +Packing,88.0,11.984707018673545,4 +Packing,90.0,9.994687701223432,4 +Packing,92.0,7.996941403734691,4 +Packing,94.0,5.997102382485493,4 +Packing,96.0,5.635383129426896,4 +Packing,98.0,5.6012556342562565,4 +Packing,100.0,5.58322601416611,4 +Packing,102.0,5.555859626529277,4 +Packing,104.0,5.537990985189934,4 +Packing,106.0,5.532839665164177,4 +Packing,108.0,5.499517063747563,4 +Packing,110.0,5.490019317450074,4 +Packing,112.0,5.487443657437195,4 +Packing,114.0,5.450901481004486,4 +Packing,116.0,5.417417900837066,4 +Packing,118.0,5.408886027044405,4 +Packing,120.0,5.3934320669671365,4 +Packing,2.0,97.98164842240823,5 +Packing,4.0,95.98905344494527,5 +Packing,6.0,93.99098518995494,5 +Packing,8.0,91.99581455247912,5 +Packing,10.0,89.98470701867359,5 +Packing,12.0,87.99919510624605,5 +Packing,14.0,85.99661944623314,5 +Packing,16.0,83.99887314874437,5 +Packing,18.0,81.9903412749517,5 +Packing,20.0,79.99533161622665,5 +Packing,22.0,77.99436574372183,5 +Packing,24.0,75.99468770122346,5 +Packing,26.0,73.9956535737283,5 +Packing,28.0,71.99983902124926,5 +Packing,30.0,69.99001931745016,5 +Packing,32.0,67.99468770122355,5 +Packing,34.0,65.99034127495187,5 +Packing,36.0,63.99468770122358,5 +Packing,38.0,61.993399871217136,5 +Packing,40.0,59.991307147456666,5 +Packing,42.0,57.99098518995505,5 +Packing,44.0,55.993560849967906,5 +Packing,46.0,53.994687701223555,5 +Packing,48.0,51.92289117836454,5 +Packing,50.0,49.98857050869292,5 +Packing,52.0,47.99983902124927,5 +Packing,54.0,45.92305215711533,5 +Packing,56.0,43.9980682549904,5 +Packing,58.0,41.997907276239594,5 +Packing,60.0,39.990180296200954,5 +Packing,62.0,37.940115904700626,5 +Packing,64.0,35.98792659368966,5 +Packing,66.0,33.99323889246622,5 +Packing,68.0,31.994043786220228,5 +Packing,70.0,29.993560849967814,5 +Packing,72.0,27.99742433998712,5 +Packing,74.0,25.992273019961367,5 +Packing,76.0,23.989858338699296,5 +Packing,78.0,21.915164198325822,5 +Packing,80.0,19.994204764971023,5 +Packing,82.0,17.99983902124919,5 +Packing,84.0,15.991468126207339,5 +Packing,86.0,13.984546039922725,5 +Packing,88.0,11.991307147456528,5 +Packing,90.0,9.987604636188008,5 +Packing,92.0,7.988087572440417,5 +Packing,94.0,5.990663232453293,5 +Packing,96.0,5.477141017385683,5 +Packing,98.0,5.4745653573728035,5 +Packing,100.0,5.461687057308412,5 +Packing,102.0,5.443818415969069,5 +Packing,104.0,5.442047649710215,5 +Packing,106.0,5.439471989697338,5 +Packing,108.0,5.433354797166751,5 +Packing,110.0,5.397295556986456,5 +Packing,112.0,5.389568576947821,5 +Packing,114.0,5.35801674179006,5 +Packing,116.0,5.351094655505449,5 +Packing,118.0,5.344172569220838,5 +Packing,120.0,5.33467482292335,5 +Packing,2.0,97.98824855119123,6 +Packing,4.0,95.98551191242757,6 +Packing,6.0,93.99227301996137,6 +Packing,8.0,91.99645846748231,6 +Packing,10.0,89.94510624597555,6 +Packing,12.0,87.99388280746946,6 +Packing,14.0,85.99372182871863,6 +Packing,16.0,83.99565357372822,6 +Packing,18.0,81.98599484867984,6 +Packing,20.0,79.9977462974886,6 +Packing,22.0,77.98889246619434,6 +Packing,24.0,75.9935608499677,6 +Packing,26.0,73.99597553122977,6 +Packing,28.0,71.98422408242104,6 +Packing,30.0,69.98180940115896,6 +Packing,32.0,67.9922730199614,6 +Packing,34.0,65.99339987121714,6 +Packing,36.0,63.99517063747599,6 +Packing,38.0,61.995009658725166,6 +Packing,40.0,59.98390212491963,6 +Packing,42.0,57.99452672247275,6 +Packing,44.0,55.9964584674824,6 +Packing,46.0,53.987926593689735,6 +Packing,48.0,51.998390212492055,6 +Packing,50.0,49.999517063747675,6 +Packing,52.0,47.989214423696154,6 +Packing,54.0,45.99726336123639,6 +Packing,56.0,43.993882807469475,6 +Packing,58.0,41.99919510624604,6 +Packing,60.0,39.99339987121706,6 +Packing,62.0,37.995492594977506,6 +Packing,64.0,35.984707018673575,6 +Packing,66.0,33.987121699935635,6 +Packing,68.0,31.98712169993564,6 +Packing,70.0,29.984063103670334,6 +Packing,72.0,27.993077913715403,6 +Packing,74.0,25.99420476497104,6 +Packing,76.0,23.993721828718623,6 +Packing,78.0,21.998712169993578,6 +Packing,80.0,19.98116548615584,6 +Packing,82.0,17.996458467482306,6 +Packing,84.0,15.996780424983914,6 +Packing,86.0,13.996136509980689,6 +Packing,88.0,11.998229233741155,6 +Packing,90.0,9.990019317450091,6 +Packing,92.0,7.989375402446859,6 +Packing,94.0,5.914198325820974,6 +Packing,96.0,5.771571152607838,6 +Packing,98.0,5.740824211204103,6 +Packing,100.0,5.725370251126831,6 +Packing,102.0,5.698164842240803,6 +Packing,104.0,5.686413393432045,6 +Packing,106.0,5.683837733419166,6 +Packing,108.0,5.676110753380533,6 +Packing,110.0,5.665808113329018,6 +Packing,112.0,5.644558918222772,6 +Packing,114.0,5.632485511912404,6 +Packing,116.0,5.624758531873769,6 +Packing,118.0,5.613650998068231,6 +Packing,120.0,5.593206696716011,6 +Packing,2.0,97.99533161622664,7 +Packing,4.0,95.99372182871859,7 +Packing,6.0,93.99951706374759,7 +Packing,8.0,91.99195106245979,7 +Packing,10.0,89.99275595621386,7 +Packing,12.0,87.99806825499047,7 +Packing,14.0,85.98760463618811,7 +Packing,16.0,83.99388280746942,7 +Packing,18.0,81.98518995492594,7 +Packing,20.0,79.99549259497749,7 +Packing,22.0,77.9961365099807,7 +Packing,24.0,75.98969735994852,7 +Packing,26.0,73.9885705086929,7 +Packing,28.0,71.98567289117848,7 +Packing,30.0,69.99549259497755,7 +Packing,32.0,67.99661944623324,7 +Packing,34.0,65.99613650998086,7 +Packing,36.0,63.97794591113988,7 +Packing,38.0,61.98921442369619,7 +Packing,40.0,59.99855119124287,7 +Packing,42.0,57.99356084996792,7 +Packing,44.0,55.98615582743089,7 +Packing,46.0,53.96522858982625,7 +Packing,48.0,51.949935608499786,7 +Packing,50.0,49.98696072118491,7 +Packing,52.0,47.984546039922826,7 +Packing,54.0,45.97311654861568,7 +Packing,56.0,43.9977462974888,7 +Packing,58.0,41.99018029620096,7 +Packing,60.0,39.998873148744416,7 +Packing,62.0,37.99935608499683,7 +Packing,64.0,35.99822923374119,7 +Packing,66.0,33.994204764971066,7 +Packing,68.0,31.989697359948522,7 +Packing,70.0,29.986638763683217,7 +Packing,72.0,27.991951062459776,7 +Packing,74.0,25.9961365099807,7 +Packing,76.0,23.999839021249215,7 +Packing,78.0,21.992594977463,7 +Packing,80.0,19.98567289117838,7 +Packing,82.0,17.984063103670326,7 +Packing,84.0,15.984707018673545,7 +Packing,86.0,13.997585318737926,7 +Packing,88.0,11.987604636188022,7 +Packing,90.0,9.984707018673527,7 +Packing,92.0,7.929169349645833,7 +Packing,94.0,5.9964584674822765,7 +Packing,96.0,5.840470057952336,7 +Packing,98.0,5.8065035415325035,7 +Packing,100.0,5.788473921442354,7 +Packing,102.0,5.777366387636816,7 +Packing,104.0,5.759336767546668,7 +Packing,106.0,5.74983902124918,7 +Packing,108.0,5.733580167417884,7 +Packing,110.0,5.731004507405006,7 +Packing,112.0,5.726658081133274,7 +Packing,114.0,5.721506761107518,7 +Packing,116.0,5.706857694784273,7 +Packing,118.0,5.693174500965857,7 +Packing,120.0,5.686252414681247,7 +Packing,2.0,97.98760463618801,8 +Packing,4.0,95.98792659368962,8 +Packing,6.0,93.9896973599485,8 +Packing,8.0,91.99500965872507,8 +Packing,10.0,89.9913071474566,8 +Packing,12.0,87.98502897617524,8 +Packing,14.0,85.99339987121702,8 +Packing,16.0,83.99597553122983,8 +Packing,18.0,81.99855119124268,8 +Packing,20.0,79.99678042498387,8 +Packing,22.0,77.99629748873143,8 +Packing,24.0,75.99050225370246,8 +Packing,26.0,73.99758531873789,8 +Packing,28.0,71.91870573084354,8 +Packing,30.0,69.9913071474566,8 +Packing,32.0,67.99066323245341,8 +Packing,34.0,65.99839021249213,8 +Packing,36.0,63.99356084996797,8 +Packing,38.0,61.985511912427704,8 +Packing,40.0,59.98406310367045,8 +Packing,42.0,57.98824855119137,8 +Packing,44.0,55.9995170637477,8 +Packing,46.0,53.92627173213148,8 +Packing,48.0,51.988731487443765,8 +Packing,50.0,49.87974887314886,8 +Packing,52.0,47.99372182871872,8 +Packing,54.0,45.987443657437325,8 +Packing,56.0,43.98583386992926,8 +Packing,58.0,41.99758531873801,8 +Packing,60.0,39.9974243399872,8 +Packing,62.0,37.99935608499684,8 +Packing,64.0,35.9982292337412,8 +Packing,66.0,33.98438506117196,8 +Packing,68.0,31.990502253702534,8 +Packing,70.0,29.998873148744394,8 +Packing,72.0,27.993077913715407,8 +Packing,74.0,25.99323889246621,8 +Packing,76.0,23.99790727623955,8 +Packing,78.0,21.999517063747586,8 +Packing,80.0,19.999839021249198,8 +Packing,82.0,17.973116548615582,8 +Packing,84.0,15.988731487443655,8 +Packing,86.0,13.99066323245331,8 +Packing,88.0,11.988409529942036,8 +Packing,90.0,9.997585318737906,8 +Packing,92.0,7.985833869929143,8 +Packing,94.0,5.994526722472607,8 +Packing,96.0,5.539439793947173,8 +Packing,98.0,5.5376690276883185,8 +Packing,100.0,5.513039278815168,8 +Packing,102.0,5.495170637475826,8 +Packing,104.0,5.469735994848653,8 +Packing,106.0,5.4628139085640415,8 +Packing,108.0,5.458467482292309,8 +Packing,110.0,5.452511268512527,8 +Packing,112.0,5.445589182227916,8 +Packing,114.0,5.440437862202161,8 +Packing,116.0,5.435286542176404,8 +Packing,118.0,5.4191886670959155,8 +Packing,120.0,5.414037347070158,8 +Packing,2.0,97.98486799742435,9 +Packing,4.0,95.9962974887315,9 +Packing,6.0,93.98470701867355,9 +Packing,8.0,91.98969735994851,9 +Packing,10.0,89.9922730199614,9 +Packing,12.0,87.99806825499043,9 +Packing,14.0,85.98647778493243,9 +Packing,16.0,83.99919510624592,9 +Packing,18.0,81.98857050869277,9 +Packing,20.0,79.9882485511912,9 +Packing,22.0,77.98905344494521,9 +Packing,24.0,75.99871216999352,9 +Packing,26.0,73.99420476497099,9 +Packing,28.0,71.99130714745652,9 +Packing,30.0,69.98502897617517,9 +Packing,32.0,67.99774629748883,9 +Packing,34.0,65.99211204121069,9 +Packing,36.0,63.987121699935734,9 +Packing,38.0,61.90148100450752,9 +Packing,40.0,59.9962974887316,9 +Packing,42.0,57.999195106246084,9 +Packing,44.0,55.99774629748884,9 +Packing,46.0,53.99323889246629,9 +Packing,48.0,51.9771410173858,9 +Packing,50.0,49.9839021249196,9 +Packing,52.0,47.9776239536382,9 +Packing,54.0,45.989858338699364,9 +Packing,56.0,43.993882807469475,9 +Packing,58.0,41.991790083709006,9 +Packing,60.0,39.99082421120418,9 +Packing,62.0,37.997102382485565,9 +Packing,64.0,35.98808757244048,9 +Packing,66.0,33.98840952994207,9 +Packing,68.0,31.995653573728294,9 +Packing,70.0,29.98438506117195,9 +Packing,72.0,27.99694140373472,9 +Packing,74.0,25.99420476497104,9 +Packing,76.0,23.997263361236328,9 +Packing,78.0,21.993077913715396,9 +Packing,80.0,19.995975531229888,9 +Packing,82.0,17.98905344494527,9 +Packing,84.0,15.997907276239538,9 +Packing,86.0,13.995653573728267,9 +Packing,88.0,11.996619446233094,9 +Packing,90.0,9.992273019961353,9 +Packing,92.0,7.994848679974225,9 +Packing,94.0,5.9950096587250306,9 +Packing,96.0,5.558757244043768,9 +Packing,98.0,5.552318094011572,9 +Packing,100.0,5.51738570508691,9 +Packing,102.0,5.514810045074032,9 +Packing,104.0,5.506278171281373,9 +Packing,106.0,5.5019317450096406,9 +Packing,108.0,5.460238248551173,9 +Packing,110.0,5.452189311010929,9 +Packing,112.0,5.447037990985171,9 +Packing,114.0,5.445267224726318,9 +Packing,116.0,5.416291049581438,9 +Packing,118.0,5.416291049581438,9 +Packing,120.0,5.400193174500948,9 +Clustering,2.0,97.99822923374113,0 +Clustering,4.0,95.98599484867997,0 +Clustering,6.0,93.98502897617516,0 +Clustering,8.0,91.98535093367677,0 +Clustering,10.0,89.99581455247912,0 +Clustering,12.0,87.99549259497752,0 +Clustering,14.0,85.994204764971,0 +Clustering,16.0,83.97198969735989,0 +Clustering,18.0,81.98840952994203,0 +Clustering,20.0,79.9916291049581,0 +Clustering,22.0,77.99259497746293,0 +Clustering,24.0,75.99388280746939,0 +Clustering,26.0,73.99275595621377,0 +Clustering,28.0,71.98776561493881,0 +Clustering,30.0,69.99726336123632,0 +Clustering,32.0,67.97987765614945,0 +Clustering,34.0,65.99710238248562,0 +Clustering,36.0,63.946877012234495,0 +Clustering,38.0,61.96571152607867,0 +Clustering,40.0,59.986960721184914,0 +Clustering,42.0,57.995814552479175,0 +Clustering,44.0,55.991951062459854,0 +Clustering,46.0,53.99629748873159,0 +Clustering,48.0,51.99066323245341,0 +Clustering,50.0,49.991629104958236,0 +Clustering,52.0,47.938828074694214,0 +Clustering,54.0,45.98985833869936,0 +Clustering,56.0,43.984063103670366,0 +Clustering,58.0,41.98873148744371,0 +Clustering,60.0,39.98921442369611,0 +Clustering,62.0,37.99436574372187,0 +Clustering,64.0,35.98873148744367,0 +Clustering,66.0,33.995653573728276,0 +Clustering,68.0,31.995331616226668,0 +Clustering,70.0,29.9995170637476,0 +Clustering,72.0,27.995653573728273,0 +Clustering,74.0,25.96233097231166,0 +Clustering,76.0,23.987282678686412,0 +Clustering,78.0,21.990663232453315,0 +Clustering,80.0,19.985511912427565,0 +Clustering,82.0,17.99130714745654,0 +Clustering,84.0,15.929491307147462,0 +Clustering,86.0,13.997102382485513,0 +Clustering,88.0,11.985672891178362,0 +Clustering,90.0,9.997907276239525,0 +Clustering,92.0,7.999195106245958,0 +Clustering,94.0,5.98873148744364,0 +Clustering,96.0,5.762556342562765,0 +Clustering,98.0,5.75482936252413,0 +Clustering,100.0,5.736155827430762,0 +Clustering,102.0,5.73277527366386,0 +Clustering,104.0,5.725853187379249,0 +Clustering,106.0,5.707179652285881,0 +Clustering,108.0,5.7012234385061,0 +Clustering,110.0,5.68963296844815,0 +Clustering,112.0,5.669993560849951,0 +Clustering,114.0,5.667417900837073,0 +Clustering,116.0,5.643593045717949,0 +Clustering,118.0,5.638441725692191,0 +Clustering,120.0,5.6194462330972135,0 +Clustering,2.0,97.98921442369607,1 +Clustering,4.0,95.9929169349646,1 +Clustering,6.0,93.98679974243402,1 +Clustering,8.0,91.9748873148745,1 +Clustering,10.0,89.99034127495177,1 +Clustering,12.0,87.99758531873803,1 +Clustering,14.0,85.9959755312299,1 +Clustering,16.0,83.98824855119115,1 +Clustering,18.0,81.98985833869918,1 +Clustering,20.0,79.99661944623303,1 +Clustering,22.0,77.98728267868636,1 +Clustering,24.0,75.99597553122985,1 +Clustering,26.0,73.99597553122985,1 +Clustering,28.0,71.98824855119128,1 +Clustering,30.0,69.99227301996139,1 +Clustering,32.0,67.99001931745022,1 +Clustering,34.0,65.99855119124291,1 +Clustering,36.0,63.99806825499047,1 +Clustering,38.0,61.984385061172034,1 +Clustering,40.0,59.985672891178474,1 +Clustering,42.0,57.990019317450205,1 +Clustering,44.0,55.989536381197794,1 +Clustering,46.0,53.997585318738025,1 +Clustering,48.0,51.99581455247917,1 +Clustering,50.0,49.89649066323255,1 +Clustering,52.0,47.998712169993645,1 +Clustering,54.0,45.98985833869938,1 +Clustering,56.0,43.990019317450155,1 +Clustering,58.0,41.99726336123638,1 +Clustering,60.0,39.991790083709006,1 +Clustering,62.0,37.99549259497753,1 +Clustering,64.0,35.999356084996826,1 +Clustering,66.0,33.99903412749521,1 +Clustering,68.0,31.991146168705765,1 +Clustering,70.0,29.99758531873795,1 +Clustering,72.0,27.987926593689654,1 +Clustering,74.0,25.998873148744384,1 +Clustering,76.0,23.994365743721843,1 +Clustering,78.0,21.993721828718613,1 +Clustering,80.0,19.986316806181588,1 +Clustering,82.0,17.99339987121701,1 +Clustering,84.0,15.987765614938834,1 +Clustering,86.0,13.993399871217003,1 +Clustering,88.0,11.999034127495165,1 +Clustering,90.0,9.990824211204108,1 +Clustering,92.0,7.9905022537024974,1 +Clustering,94.0,5.998551191242741,1 +Clustering,96.0,5.634417256922072,1 +Clustering,98.0,5.629265936896315,1 +Clustering,100.0,5.619768190598827,1 +Clustering,102.0,5.587572440437848,1 +Clustering,104.0,5.57646490663231,1 +Clustering,106.0,5.570508692852529,1 +Clustering,108.0,5.552640051513187,1 +Clustering,110.0,5.552640051513187,1 +Clustering,112.0,5.524951706374744,1 +Clustering,114.0,5.502897617514474,1 +Clustering,116.0,5.465550547327739,1 +Clustering,118.0,5.448325820991614,1 +Clustering,120.0,5.435447520927224,1 +Clustering,2.0,97.9320669671603,2 +Clustering,4.0,95.99517063747582,2 +Clustering,6.0,93.98889246619446,2 +Clustering,8.0,91.98712169993561,2 +Clustering,10.0,89.98712169993568,2 +Clustering,12.0,87.99951706374763,2 +Clustering,14.0,85.99565357372823,2 +Clustering,16.0,83.98712169993553,2 +Clustering,18.0,81.9962974887314,2 +Clustering,20.0,79.98873148744357,2 +Clustering,22.0,77.99356084996774,2 +Clustering,24.0,75.99726336123626,2 +Clustering,26.0,73.9971023824855,2 +Clustering,28.0,71.99935608499682,2 +Clustering,30.0,69.99372182871865,2 +Clustering,32.0,67.98857050869294,2 +Clustering,34.0,65.99420476497116,2 +Clustering,36.0,63.98309723116561,2 +Clustering,38.0,61.99758531873805,2 +Clustering,40.0,59.98905344494537,2 +Clustering,42.0,57.991951062459854,2 +Clustering,44.0,55.9966194462332,2 +Clustering,46.0,53.99243399871227,2 +Clustering,48.0,51.98728267868651,2 +Clustering,50.0,49.99645846748239,2 +Clustering,52.0,47.99533161622675,2 +Clustering,54.0,45.99066323245341,2 +Clustering,56.0,43.99082421120419,2 +Clustering,58.0,41.995492594977534,2 +Clustering,60.0,39.99404378622027,2 +Clustering,62.0,37.995009658725095,2 +Clustering,64.0,35.99452672247268,2 +Clustering,66.0,33.99372182871865,2 +Clustering,68.0,31.99356084996782,2 +Clustering,70.0,29.999356084996798,2 +Clustering,72.0,27.991790083708967,2 +Clustering,74.0,25.99855119124278,2 +Clustering,76.0,23.999195106245992,2 +Clustering,78.0,21.995331616226675,2 +Clustering,80.0,19.9930779137154,2 +Clustering,82.0,17.984063103670326,2 +Clustering,84.0,15.991790083708961,2 +Clustering,86.0,13.99549259497747,2 +Clustering,88.0,11.99790727623954,2 +Clustering,90.0,9.994848679974229,2 +Clustering,92.0,7.990985189954909,2 +Clustering,94.0,6.0183515775917416,2 +Clustering,96.0,5.972955569864763,2 +Clustering,98.0,5.956857694784273,2 +Clustering,100.0,5.941403734707004,2 +Clustering,102.0,5.927559562137784,2 +Clustering,104.0,5.903734707018659,2 +Clustering,106.0,5.896007726980025,2 +Clustering,108.0,5.896007726980025,2 +Clustering,110.0,5.883129426915632,2 +Clustering,112.0,5.870251126851241,2 +Clustering,114.0,5.8277527366387485,2 +Clustering,116.0,5.780907920154524,2 +Clustering,118.0,5.780907920154524,2 +Clustering,120.0,5.773180940115888,2 +Clustering,2.0,97.99694140373472,3 +Clustering,4.0,95.99388280746943,3 +Clustering,6.0,93.999195106246,3 +Clustering,8.0,91.99661944623315,3 +Clustering,10.0,89.99661944623318,3 +Clustering,12.0,87.99146812620745,3 +Clustering,14.0,85.98921442369604,3 +Clustering,16.0,83.98470701867348,3 +Clustering,18.0,81.9848679974243,3 +Clustering,20.0,79.98583386992915,3 +Clustering,22.0,77.99066323245329,3 +Clustering,24.0,75.99871216999357,3 +Clustering,26.0,73.99146812620737,3 +Clustering,28.0,71.99291693496467,3 +Clustering,30.0,69.99517063747594,3 +Clustering,32.0,67.99903412749528,3 +Clustering,34.0,65.98551191242768,3 +Clustering,36.0,63.99597553122999,3 +Clustering,38.0,61.98776561493893,3 +Clustering,40.0,59.980682549903506,3 +Clustering,42.0,57.99629748873157,3 +Clustering,44.0,55.9905022537026,3 +Clustering,46.0,53.99066323245341,3 +Clustering,48.0,51.99871216999363,3 +Clustering,50.0,49.989536381197766,3 +Clustering,52.0,47.98551191242762,3 +Clustering,54.0,45.98535093367681,3 +Clustering,56.0,43.99790727623959,3 +Clustering,58.0,41.98631680618162,3 +Clustering,60.0,39.98406310367035,3 +Clustering,62.0,37.987765614938866,3 +Clustering,64.0,35.984385061171956,3 +Clustering,66.0,33.97392144236965,3 +Clustering,68.0,31.997907276239566,3 +Clustering,70.0,29.9953316162267,3 +Clustering,72.0,27.987926593689664,3 +Clustering,74.0,25.989697359948522,3 +Clustering,76.0,23.998551191242793,3 +Clustering,78.0,21.998068254990375,3 +Clustering,80.0,19.999195106246002,3 +Clustering,82.0,17.992433998712183,3 +Clustering,84.0,15.999195106245983,3 +Clustering,86.0,13.995170637475853,3 +Clustering,88.0,11.995653573728266,3 +Clustering,90.0,9.996780424983895,3 +Clustering,92.0,7.997263361236307,3 +Clustering,94.0,5.994365743721819,3 +Clustering,96.0,5.854958145524781,3 +Clustering,98.0,5.836284610431415,3 +Clustering,100.0,5.829362524146804,3 +Clustering,102.0,5.824211204121047,3 +Clustering,104.0,5.81905988409529,3 +Clustering,106.0,5.740019317450088,3 +Clustering,108.0,5.734063103670308,3 +Clustering,110.0,5.713618802318086,3 +Clustering,112.0,5.706696716033475,3 +Clustering,114.0,5.681101094655497,3 +Clustering,116.0,5.663876368319373,3 +Clustering,118.0,5.656954282034763,3 +Clustering,120.0,5.624758531873785,3 +Clustering,2.0,97.9966194462331,4 +Clustering,4.0,95.99629748873149,4 +Clustering,6.0,93.9998390212492,4 +Clustering,8.0,91.99710238248552,4 +Clustering,10.0,89.99726336123636,4 +Clustering,12.0,87.98792659368968,4 +Clustering,14.0,85.99323889246622,4 +Clustering,16.0,83.99227301996127,4 +Clustering,18.0,81.99533161622644,4 +Clustering,20.0,79.9903412749515,4 +Clustering,22.0,77.99565357372806,4 +Clustering,24.0,75.99420476497085,4 +Clustering,26.0,73.93947198969721,4 +Clustering,28.0,71.99710238248538,4 +Clustering,30.0,69.99452672247256,4 +Clustering,32.0,67.90534449452677,4 +Clustering,34.0,65.99710238248568,4 +Clustering,36.0,63.98358016741806,4 +Clustering,38.0,61.99517063747601,4 +Clustering,40.0,59.98889246619461,4 +Clustering,42.0,57.99710238248566,4 +Clustering,44.0,55.99629748873163,4 +Clustering,46.0,53.99887314874451,4 +Clustering,48.0,51.99871216999371,4 +Clustering,50.0,49.99323889246634,4 +Clustering,52.0,47.994526722472756,4 +Clustering,54.0,45.99356084996793,4 +Clustering,56.0,43.99484867997436,4 +Clustering,58.0,41.98953638119779,4 +Clustering,60.0,39.99082421120422,4 +Clustering,62.0,37.991146168705825,4 +Clustering,64.0,35.994848679974304,4 +Clustering,66.0,33.99146812620737,4 +Clustering,68.0,31.988892466194496,4 +Clustering,70.0,29.997424339987155,4 +Clustering,72.0,27.99018029620094,4 +Clustering,74.0,25.999356084996805,4 +Clustering,76.0,23.99533161622668,4 +Clustering,78.0,21.99694140373473,4 +Clustering,80.0,19.99291693496461,4 +Clustering,82.0,18.000000000000018,4 +Clustering,84.0,15.98583386992919,4 +Clustering,86.0,13.990663232453333,4 +Clustering,88.0,11.984707018673545,4 +Clustering,90.0,9.994687701223436,4 +Clustering,92.0,7.996941403734693,4 +Clustering,94.0,5.997102382485496,4 +Clustering,96.0,5.6353831294268995,4 +Clustering,98.0,5.601255634256259,4 +Clustering,100.0,5.5832260141661125,4 +Clustering,102.0,5.55585962652928,4 +Clustering,104.0,5.537990985189938,4 +Clustering,106.0,5.532839665164182,4 +Clustering,108.0,5.499517063747569,4 +Clustering,110.0,5.4900193174500815,4 +Clustering,112.0,5.487443657437203,4 +Clustering,114.0,5.450901481004492,4 +Clustering,116.0,5.4174179008370755,4 +Clustering,118.0,5.4088860270444155,4 +Clustering,120.0,5.393432066967145,4 +Clustering,2.0,97.98164842240823,5 +Clustering,4.0,95.98905344494527,5 +Clustering,6.0,93.99098518995496,5 +Clustering,8.0,91.99581455247912,5 +Clustering,10.0,89.98470701867359,5 +Clustering,12.0,87.99919510624605,5 +Clustering,14.0,85.99661944623314,5 +Clustering,16.0,83.99887314874437,5 +Clustering,18.0,81.9903412749517,5 +Clustering,20.0,79.99533161622666,5 +Clustering,22.0,77.99436574372184,5 +Clustering,24.0,75.99468770122344,5 +Clustering,26.0,73.99565357372829,5 +Clustering,28.0,71.99983902124923,5 +Clustering,30.0,69.99001931745012,5 +Clustering,32.0,67.99468770122353,5 +Clustering,34.0,65.99034127495185,5 +Clustering,36.0,63.99468770122356,5 +Clustering,38.0,61.99339987121712,5 +Clustering,40.0,59.991307147456666,5 +Clustering,42.0,57.99098518995503,5 +Clustering,44.0,55.993560849967906,5 +Clustering,46.0,53.99468770122354,5 +Clustering,48.0,51.92289117836454,5 +Clustering,50.0,49.98857050869292,5 +Clustering,52.0,47.99983902124925,5 +Clustering,54.0,45.92305215711532,5 +Clustering,56.0,43.9980682549904,5 +Clustering,58.0,41.99790727623959,5 +Clustering,60.0,39.99018029620095,5 +Clustering,62.0,37.940115904700626,5 +Clustering,64.0,35.98792659368966,5 +Clustering,66.0,33.9932388924662,5 +Clustering,68.0,31.994043786220228,5 +Clustering,70.0,29.99356084996781,5 +Clustering,72.0,27.99742433998712,5 +Clustering,74.0,25.992273019961367,5 +Clustering,76.0,23.98985833869929,5 +Clustering,78.0,21.915164198325822,5 +Clustering,80.0,19.994204764971027,5 +Clustering,82.0,17.999839021249205,5 +Clustering,84.0,15.99146812620735,5 +Clustering,86.0,13.984546039922735,5 +Clustering,88.0,11.991307147456537,5 +Clustering,90.0,9.987604636188017,5 +Clustering,92.0,7.988087572440425,5 +Clustering,94.0,5.990663232453305,5 +Clustering,96.0,5.535093367675454,5 +Clustering,98.0,5.532517707662576,5 +Clustering,100.0,5.519639407598185,5 +Clustering,102.0,5.501770766258842,5 +Clustering,104.0,5.4999999999999885,5 +Clustering,106.0,5.49742433998711,5 +Clustering,108.0,5.491307147456524,5 +Clustering,110.0,5.455247907276228,5 +Clustering,112.0,5.447520927237593,5 +Clustering,114.0,5.415969092079834,5 +Clustering,116.0,5.409047005795223,5 +Clustering,118.0,5.402124919510611,5 +Clustering,120.0,5.392627173213121,5 +Clustering,2.0,97.98824855119123,6 +Clustering,4.0,95.98551191242755,6 +Clustering,6.0,93.99227301996137,6 +Clustering,8.0,91.99645846748231,6 +Clustering,10.0,89.94510624597557,6 +Clustering,12.0,87.99388280746948,6 +Clustering,14.0,85.99372182871862,6 +Clustering,16.0,83.99565357372822,6 +Clustering,18.0,81.98599484867991,6 +Clustering,20.0,79.99774629748866,6 +Clustering,22.0,77.98889246619439,6 +Clustering,24.0,75.99356084996774,6 +Clustering,26.0,73.99597553122982,6 +Clustering,28.0,71.9842240824211,6 +Clustering,30.0,69.981809401159,6 +Clustering,32.0,67.9922730199614,6 +Clustering,34.0,65.9933998712171,6 +Clustering,36.0,63.99517063747594,6 +Clustering,38.0,61.995009658725145,6 +Clustering,40.0,59.98390212491961,6 +Clustering,42.0,57.99452672247271,6 +Clustering,44.0,55.99645846748237,6 +Clustering,46.0,53.98792659368971,6 +Clustering,48.0,51.99839021249202,6 +Clustering,50.0,49.99951706374765,6 +Clustering,52.0,47.98921442369613,6 +Clustering,54.0,45.99726336123638,6 +Clustering,56.0,43.99388280746946,6 +Clustering,58.0,41.99919510624602,6 +Clustering,60.0,39.993399871217036,6 +Clustering,62.0,37.995492594977506,6 +Clustering,64.0,35.984707018673575,6 +Clustering,66.0,33.987121699935635,6 +Clustering,68.0,31.98712169993564,6 +Clustering,70.0,29.984063103670337,6 +Clustering,72.0,27.993077913715407,6 +Clustering,74.0,25.99420476497104,6 +Clustering,76.0,23.99372182871862,6 +Clustering,78.0,21.998712169993578,6 +Clustering,80.0,19.981165486155838,6 +Clustering,82.0,17.996458467482302,6 +Clustering,84.0,15.996780424983909,6 +Clustering,86.0,13.996136509980683,6 +Clustering,88.0,11.998229233741146,6 +Clustering,90.0,9.990019317450086,6 +Clustering,92.0,7.989375402446861,6 +Clustering,94.0,5.914198325820976,6 +Clustering,96.0,5.595299420476482,6 +Clustering,98.0,5.568094011590454,6 +Clustering,100.0,5.552640051513183,6 +Clustering,102.0,5.525434642627157,6 +Clustering,104.0,5.513683193818399,6 +Clustering,106.0,5.511107533805521,6 +Clustering,108.0,5.5033805537668865,6 +Clustering,110.0,5.493077913715372,6 +Clustering,112.0,5.4718287186091255,6 +Clustering,114.0,5.45975531229876,6 +Clustering,116.0,5.452028332260124,6 +Clustering,118.0,5.440920798454585,6 +Clustering,120.0,5.4204764971023645,6 +Clustering,2.0,97.99533161622664,7 +Clustering,4.0,95.99372182871859,7 +Clustering,6.0,93.99951706374759,7 +Clustering,8.0,91.99195106245979,7 +Clustering,10.0,89.99275595621386,7 +Clustering,12.0,87.99806825499049,7 +Clustering,14.0,85.98760463618808,7 +Clustering,16.0,83.99388280746938,7 +Clustering,18.0,81.9851899549259,7 +Clustering,20.0,79.99549259497745,7 +Clustering,22.0,77.99613650998066,7 +Clustering,24.0,75.98969735994847,7 +Clustering,26.0,73.98857050869285,7 +Clustering,28.0,71.98567289117842,7 +Clustering,30.0,69.99549259497752,7 +Clustering,32.0,67.99661944623321,7 +Clustering,34.0,65.99613650998083,7 +Clustering,36.0,63.97794591113987,7 +Clustering,38.0,61.98921442369619,7 +Clustering,40.0,59.99855119124287,7 +Clustering,42.0,57.99356084996792,7 +Clustering,44.0,55.986155827430885,7 +Clustering,46.0,53.96522858982625,7 +Clustering,48.0,51.94993560849978,7 +Clustering,50.0,49.9869607211849,7 +Clustering,52.0,47.984546039922805,7 +Clustering,54.0,45.973116548615664,7 +Clustering,56.0,43.9977462974888,7 +Clustering,58.0,41.990180296200975,7 +Clustering,60.0,39.998873148744416,7 +Clustering,62.0,37.99935608499683,7 +Clustering,64.0,35.99822923374119,7 +Clustering,66.0,33.994204764971066,7 +Clustering,68.0,31.989697359948526,7 +Clustering,70.0,29.98663876368323,7 +Clustering,72.0,27.991951062459787,7 +Clustering,74.0,25.996136509980705,7 +Clustering,76.0,23.999839021249215,7 +Clustering,78.0,21.992594977462986,7 +Clustering,80.0,19.98567289117838,7 +Clustering,82.0,17.984063103670326,7 +Clustering,84.0,15.984707018673546,7 +Clustering,86.0,13.997585318737935,7 +Clustering,88.0,11.98760463618803,7 +Clustering,90.0,9.984707018673529,7 +Clustering,92.0,7.929169349645836,7 +Clustering,94.0,5.996458467482279,7 +Clustering,96.0,5.8404700579523405,7 +Clustering,98.0,5.806503541532507,7 +Clustering,100.0,5.788473921442358,7 +Clustering,102.0,5.777366387636819,7 +Clustering,104.0,5.759336767546673,7 +Clustering,106.0,5.749839021249184,7 +Clustering,108.0,5.73358016741789,7 +Clustering,110.0,5.731004507405012,7 +Clustering,112.0,5.726658081133278,7 +Clustering,114.0,5.721506761107522,7 +Clustering,116.0,5.706857694784274,7 +Clustering,118.0,5.693174500965856,7 +Clustering,120.0,5.686252414681245,7 +Clustering,2.0,97.98760463618801,8 +Clustering,4.0,95.98792659368965,8 +Clustering,6.0,93.98969735994851,8 +Clustering,8.0,91.99500965872508,8 +Clustering,10.0,89.99130714745661,8 +Clustering,12.0,87.98502897617524,8 +Clustering,14.0,85.99339987121702,8 +Clustering,16.0,83.99597553122985,8 +Clustering,18.0,81.9985511912427,8 +Clustering,20.0,79.99678042498385,8 +Clustering,22.0,77.99629748873143,8 +Clustering,24.0,75.99050225370246,8 +Clustering,26.0,73.99758531873792,8 +Clustering,28.0,71.91870573084351,8 +Clustering,30.0,69.99130714745657,8 +Clustering,32.0,67.99066323245341,8 +Clustering,34.0,65.99839021249211,8 +Clustering,36.0,63.993560849967935,8 +Clustering,38.0,61.9855119124277,8 +Clustering,40.0,59.98406310367044,8 +Clustering,42.0,57.988248551191354,8 +Clustering,44.0,55.9995170637477,8 +Clustering,46.0,53.92627173213148,8 +Clustering,48.0,51.988731487443765,8 +Clustering,50.0,49.87974887314885,8 +Clustering,52.0,47.99372182871869,8 +Clustering,54.0,45.987443657437304,8 +Clustering,56.0,43.98583386992925,8 +Clustering,58.0,41.997585318738,8 +Clustering,60.0,39.997424339987184,8 +Clustering,62.0,37.99935608499684,8 +Clustering,64.0,35.9982292337412,8 +Clustering,66.0,33.98438506117196,8 +Clustering,68.0,31.990502253702545,8 +Clustering,70.0,29.99887314874441,8 +Clustering,72.0,27.993077913715425,8 +Clustering,74.0,25.99323889246623,8 +Clustering,76.0,23.997907276239566,8 +Clustering,78.0,21.9995170637476,8 +Clustering,80.0,19.999839021249215,8 +Clustering,82.0,17.97311654861559,8 +Clustering,84.0,15.988731487443667,8 +Clustering,86.0,13.990663232453318,8 +Clustering,88.0,11.98840952994204,8 +Clustering,90.0,9.997585318737915,8 +Clustering,92.0,7.985833869929149,8 +Clustering,94.0,5.994526722472612,8 +Clustering,96.0,5.73953638119766,8 +Clustering,98.0,5.737765614938807,8 +Clustering,100.0,5.713135866065658,8 +Clustering,102.0,5.691725692208608,8 +Clustering,104.0,5.666291049581433,8 +Clustering,106.0,5.659368963296823,8 +Clustering,108.0,5.655022537025093,8 +Clustering,110.0,5.649066323245311,8 +Clustering,112.0,5.6421442369607,8 +Clustering,114.0,5.636992916934943,8 +Clustering,116.0,5.631841596909187,8 +Clustering,118.0,5.631841596909187,8 +Clustering,120.0,5.62669027688343,8 +Clustering,2.0,97.98486799742432,9 +Clustering,4.0,95.99629748873149,9 +Clustering,6.0,93.98470701867355,9 +Clustering,8.0,91.98969735994854,9 +Clustering,10.0,89.99227301996142,9 +Clustering,12.0,87.99806825499044,9 +Clustering,14.0,85.98647778493242,9 +Clustering,16.0,83.99919510624592,9 +Clustering,18.0,81.98857050869273,9 +Clustering,20.0,79.98824855119119,9 +Clustering,22.0,77.9890534449452,9 +Clustering,24.0,75.99871216999348,9 +Clustering,26.0,73.99420476497096,9 +Clustering,28.0,71.99130714745654,9 +Clustering,30.0,69.98502897617513,9 +Clustering,32.0,67.99774629748882,9 +Clustering,34.0,65.99211204121069,9 +Clustering,36.0,63.987121699935734,9 +Clustering,38.0,61.90148100450752,9 +Clustering,40.0,59.9962974887316,9 +Clustering,42.0,57.99919510624607,9 +Clustering,44.0,55.99774629748884,9 +Clustering,46.0,53.99323889246629,9 +Clustering,48.0,51.9771410173858,9 +Clustering,50.0,49.983902124919595,9 +Clustering,52.0,47.977623953638215,9 +Clustering,54.0,45.98985833869938,9 +Clustering,56.0,43.99388280746948,9 +Clustering,58.0,41.99179008370901,9 +Clustering,60.0,39.99082421120418,9 +Clustering,62.0,37.997102382485565,9 +Clustering,64.0,35.98808757244048,9 +Clustering,66.0,33.988409529942075,9 +Clustering,68.0,31.995653573728305,9 +Clustering,70.0,29.98438506117196,9 +Clustering,72.0,27.99694140373473,9 +Clustering,74.0,25.994204764971045,9 +Clustering,76.0,23.99726336123634,9 +Clustering,78.0,21.993077913715407,9 +Clustering,80.0,19.995975531229888,9 +Clustering,82.0,17.98905344494527,9 +Clustering,84.0,15.997907276239543,9 +Clustering,86.0,13.99565357372827,9 +Clustering,88.0,11.9966194462331,9 +Clustering,90.0,9.992273019961358,9 +Clustering,92.0,7.99484867997423,9 +Clustering,94.0,5.995009658725034,9 +Clustering,96.0,5.588538312942677,9 +Clustering,98.0,5.582099162910481,9 +Clustering,100.0,5.54716677398582,9 +Clustering,102.0,5.528493238892453,9 +Clustering,104.0,5.519961365099793,9 +Clustering,106.0,5.515614938828061,9 +Clustering,108.0,5.473921442369595,9 +Clustering,110.0,5.46587250482935,9 +Clustering,112.0,5.460721184803593,9 +Clustering,114.0,5.45895041854474,9 +Clustering,116.0,5.446072118480349,9 +Clustering,118.0,5.446072118480349,9 +Clustering,120.0,5.446072118480349,9 +FGD,2.0,97.99822923374113,0 +FGD,4.0,95.98599484867995,0 +FGD,6.0,93.98502897617512,0 +FGD,8.0,91.98535093367674,0 +FGD,10.0,89.99581455247908,0 +FGD,12.0,87.99549259497745,0 +FGD,14.0,85.99420476497103,0 +FGD,16.0,83.97198969735994,0 +FGD,18.0,81.98840952994205,0 +FGD,20.0,79.99162910495816,0 +FGD,22.0,77.99259497746299,0 +FGD,24.0,75.99388280746943,0 +FGD,26.0,73.99275595621378,0 +FGD,28.0,71.98776561493882,0 +FGD,30.0,69.99726336123632,0 +FGD,32.0,67.97987765614938,0 +FGD,34.0,65.99710238248552,0 +FGD,36.0,63.946877012234395,0 +FGD,38.0,61.96571152607857,0 +FGD,40.0,59.986960721184815,0 +FGD,42.0,57.99581455247909,0 +FGD,44.0,55.991951062459755,0 +FGD,46.0,53.99629748873149,0 +FGD,48.0,51.990663232453315,0 +FGD,50.0,49.99162910495814,0 +FGD,52.0,47.938828074694136,0 +FGD,54.0,45.98985833869929,0 +FGD,56.0,43.98406310367031,0 +FGD,58.0,41.98873148744365,0 +FGD,60.0,39.98921442369607,0 +FGD,62.0,37.99436574372182,0 +FGD,64.0,35.98873148744365,0 +FGD,66.0,33.995653573728255,0 +FGD,68.0,31.99533161622665,0 +FGD,70.0,29.999517063747582,0 +FGD,72.0,27.99565357372826,0 +FGD,74.0,25.962330972311648,0 +FGD,76.0,23.987282678686405,0 +FGD,78.0,21.990663232453308,0 +FGD,80.0,19.985511912427548,0 +FGD,82.0,17.991307147456524,0 +FGD,84.0,15.929491307147442,0 +FGD,86.0,13.997102382485496,0 +FGD,88.0,11.98567289117835,0 +FGD,90.0,9.99790727623952,0 +FGD,92.0,7.999195106245955,0 +FGD,94.0,5.988731487443634,0 +FGD,96.0,5.210077269800366,0 +FGD,98.0,5.20235028976173,0 +FGD,100.0,5.1836767546683635,0 +FGD,102.0,5.180296200901461,0 +FGD,104.0,5.173374114616849,0 +FGD,106.0,5.154700579523483,0 +FGD,108.0,5.148744365743702,0 +FGD,110.0,5.13715389568575,0 +FGD,112.0,5.117514488087552,0 +FGD,114.0,5.111397295556966,0 +FGD,116.0,5.0875724404378415,0 +FGD,118.0,5.082421120412084,0 +FGD,120.0,5.063425627817106,0 +FGD,2.0,97.98921442369604,1 +FGD,4.0,95.99291693496457,1 +FGD,6.0,93.98679974243397,1 +FGD,8.0,91.97488731487444,1 +FGD,10.0,89.9903412749517,1 +FGD,12.0,87.99758531873792,1 +FGD,14.0,85.99597553122987,1 +FGD,16.0,83.98824855119125,1 +FGD,18.0,81.9898583386993,1 +FGD,20.0,79.99661944623308,1 +FGD,22.0,77.98728267868641,1 +FGD,24.0,75.99597553122987,1 +FGD,26.0,73.99597553122987,1 +FGD,28.0,71.98824855119123,1 +FGD,30.0,69.99227301996137,1 +FGD,32.0,67.9900193174501,1 +FGD,34.0,65.99855119124275,1 +FGD,36.0,63.99806825499035,1 +FGD,38.0,61.984385061171935,1 +FGD,40.0,59.98567289117837,1 +FGD,42.0,57.990019317450106,1 +FGD,44.0,55.98953638119768,1 +FGD,46.0,53.997585318737926,1 +FGD,48.0,51.99581455247907,1 +FGD,50.0,49.896490663232456,1 +FGD,52.0,47.99871216999356,1 +FGD,54.0,45.98985833869929,1 +FGD,56.0,43.9900193174501,1 +FGD,58.0,41.997263361236314,1 +FGD,60.0,39.99179008370894,1 +FGD,62.0,37.995492594977456,1 +FGD,64.0,35.999356084996776,1 +FGD,66.0,33.999034127495165,1 +FGD,68.0,31.99114616870572,1 +FGD,70.0,29.99758531873792,1 +FGD,72.0,27.98792659368962,1 +FGD,74.0,25.998873148744355,1 +FGD,76.0,23.99436574372182,1 +FGD,78.0,21.99372182871859,1 +FGD,80.0,19.986316806181573,1 +FGD,82.0,17.993399871216983,1 +FGD,84.0,15.987765614938812,1 +FGD,86.0,13.993399871216985,1 +FGD,88.0,11.999034127495154,1 +FGD,90.0,9.990824211204105,1 +FGD,92.0,7.990502253702495,1 +FGD,94.0,5.998551191242737,1 +FGD,96.0,4.8490019317449935,1 +FGD,98.0,4.843850611719238,1 +FGD,100.0,4.834352865421749,1 +FGD,102.0,4.802157115260769,1 +FGD,104.0,4.791049581455232,1 +FGD,106.0,4.785093367675451,1 +FGD,108.0,4.767224726336107,1 +FGD,110.0,4.767224726336107,1 +FGD,112.0,4.739536381197665,1 +FGD,114.0,4.717482292337395,1 +FGD,116.0,4.680135222150659,1 +FGD,118.0,4.662910495814535,1 +FGD,120.0,4.650032195750145,1 +FGD,2.0,97.93206696716035,2 +FGD,4.0,95.99517063747587,2 +FGD,6.0,93.98889246619446,2 +FGD,8.0,91.98712169993561,2 +FGD,10.0,89.98712169993563,2 +FGD,12.0,87.9995170637476,2 +FGD,14.0,85.99565357372828,2 +FGD,16.0,83.98712169993563,2 +FGD,18.0,81.9962974887315,2 +FGD,20.0,79.98873148744366,2 +FGD,22.0,77.9935608499678,2 +FGD,24.0,75.9972633612363,2 +FGD,26.0,73.99710238248551,2 +FGD,28.0,71.99935608499676,2 +FGD,30.0,69.9937218287186,2 +FGD,32.0,67.98857050869283,2 +FGD,34.0,65.99420476497102,2 +FGD,36.0,63.98309723116547,2 +FGD,38.0,61.99758531873791,2 +FGD,40.0,59.98905344494526,2 +FGD,42.0,57.99195106245975,2 +FGD,44.0,55.99661944623308,2 +FGD,46.0,53.992433998712166,2 +FGD,48.0,51.987282678686405,2 +FGD,50.0,49.99645846748228,2 +FGD,52.0,47.99533161622666,2 +FGD,54.0,45.99066323245331,2 +FGD,56.0,43.990824211204114,2 +FGD,58.0,41.995492594977456,2 +FGD,60.0,39.994043786220224,2 +FGD,62.0,37.995009658725046,2 +FGD,64.0,35.99452672247263,2 +FGD,66.0,33.993721828718606,2 +FGD,68.0,31.9935608499678,2 +FGD,70.0,29.99935608499677,2 +FGD,72.0,27.99179008370894,2 +FGD,74.0,25.998551191242747,2 +FGD,76.0,23.999195106245967,2 +FGD,78.0,21.99533161622665,2 +FGD,80.0,19.99307791371538,2 +FGD,82.0,17.984063103670305,2 +FGD,84.0,15.99179008370894,2 +FGD,86.0,13.995492594977454,2 +FGD,88.0,11.997907276239527,2 +FGD,90.0,9.994848679974236,2 +FGD,92.0,7.990985189954913,2 +FGD,94.0,5.986155827430768,2 +FGD,96.0,4.829523502897605,2 +FGD,98.0,4.813425627817115,2 +FGD,100.0,4.797971667739845,2 +FGD,102.0,4.784127495170626,2 +FGD,104.0,4.776400515131991,2 +FGD,106.0,4.768673535093355,2 +FGD,108.0,4.768673535093355,2 +FGD,110.0,4.755795235028963,2 +FGD,112.0,4.742916934964572,2 +FGD,114.0,4.716516419832568,2 +FGD,116.0,4.701867353509324,2 +FGD,118.0,4.701867353509324,2 +FGD,120.0,4.694140373470689,2 +FGD,2.0,97.99694140373468,3 +FGD,4.0,95.99388280746942,3 +FGD,6.0,93.99919510624596,3 +FGD,8.0,91.9966194462331,3 +FGD,10.0,89.9966194462331,3 +FGD,12.0,87.99146812620734,3 +FGD,14.0,85.98921442369607,3 +FGD,16.0,83.98470701867352,3 +FGD,18.0,81.98486799742433,3 +FGD,20.0,79.98583386992915,3 +FGD,22.0,77.9906632324533,3 +FGD,24.0,75.99871216999354,3 +FGD,26.0,73.99146812620735,3 +FGD,28.0,71.99291693496458,3 +FGD,30.0,69.99517063747585,3 +FGD,32.0,67.99903412749518,3 +FGD,34.0,65.98551191242757,3 +FGD,36.0,63.99597553122989,3 +FGD,38.0,61.98776561493883,3 +FGD,40.0,59.98068254990342,3 +FGD,42.0,57.996297488731486,3 +FGD,44.0,55.99050225370251,3 +FGD,46.0,53.990663232453315,3 +FGD,48.0,51.99871216999357,3 +FGD,50.0,49.98953638119768,3 +FGD,52.0,47.985511912427555,3 +FGD,54.0,45.985350933676756,3 +FGD,56.0,43.99790727623954,3 +FGD,58.0,41.986316806181584,3 +FGD,60.0,39.984063103670316,3 +FGD,62.0,37.98776561493882,3 +FGD,64.0,35.98438506117191,3 +FGD,66.0,33.973921442369594,3 +FGD,68.0,31.997907276239523,3 +FGD,70.0,29.99533161622665,3 +FGD,72.0,27.98792659368962,3 +FGD,74.0,25.989697359948472,3 +FGD,76.0,23.99855119124274,3 +FGD,78.0,21.998068254990326,3 +FGD,80.0,19.99919510624596,3 +FGD,82.0,17.99243399871215,3 +FGD,84.0,15.999195106245958,3 +FGD,86.0,13.995170637475832,3 +FGD,88.0,11.995653573728248,3 +FGD,90.0,9.996780424983882,3 +FGD,92.0,7.9972633612362936,3 +FGD,94.0,6.123148744365721,3 +FGD,96.0,5.6107533805537475,3 +FGD,98.0,5.592079845460379,3 +FGD,100.0,5.57566001287828,3 +FGD,102.0,5.570508692852524,3 +FGD,104.0,5.565357372826768,3 +FGD,106.0,5.486316806181564,3 +FGD,108.0,5.480360592401783,3 +FGD,110.0,5.459916291049562,3 +FGD,112.0,5.452994204764951,3 +FGD,114.0,5.427398583386974,3 +FGD,116.0,5.410173857050849,3 +FGD,118.0,5.38715389568575,3 +FGD,120.0,5.35495814552477,3 +FGD,2.0,97.99661944623307,4 +FGD,4.0,95.99629748873146,4 +FGD,6.0,93.99983902124917,4 +FGD,8.0,91.9971023824855,4 +FGD,10.0,89.9972633612363,4 +FGD,12.0,87.98792659368962,4 +FGD,14.0,85.99323889246618,4 +FGD,16.0,83.99227301996136,4 +FGD,18.0,81.99533161622664,4 +FGD,20.0,79.9903412749517,4 +FGD,22.0,77.99565357372828,4 +FGD,24.0,75.99420476497103,4 +FGD,26.0,73.93947198969735,4 +FGD,28.0,71.99710238248551,4 +FGD,30.0,69.99452672247264,4 +FGD,32.0,67.90534449452673,4 +FGD,34.0,65.99710238248552,4 +FGD,36.0,63.983580167417905,4 +FGD,38.0,61.99517063747586,4 +FGD,40.0,59.988892466194464,4 +FGD,42.0,57.99710238248551,4 +FGD,44.0,55.99629748873149,4 +FGD,46.0,53.998873148744366,4 +FGD,48.0,51.99871216999355,4 +FGD,50.0,49.99323889246619,4 +FGD,52.0,47.99452672247263,4 +FGD,54.0,45.99356084996779,4 +FGD,56.0,43.99484867997423,4 +FGD,58.0,41.98953638119768,4 +FGD,60.0,39.990824211204114,4 +FGD,62.0,37.991146168705725,4 +FGD,64.0,35.99484867997423,4 +FGD,66.0,33.99146812620733,4 +FGD,68.0,31.98889246619445,4 +FGD,70.0,29.997424339987113,4 +FGD,72.0,27.99018029620089,4 +FGD,74.0,25.999356084996766,4 +FGD,76.0,23.99533161622665,4 +FGD,78.0,21.996941403734695,4 +FGD,80.0,19.992916934964576,4 +FGD,82.0,17.999999999999986,4 +FGD,84.0,15.985833869929156,4 +FGD,86.0,13.990663232453304,4 +FGD,88.0,11.984707018673522,4 +FGD,90.0,9.994687701223421,4 +FGD,92.0,7.996941403734689,4 +FGD,94.0,5.997102382485491,4 +FGD,96.0,4.698969735994831,4 +FGD,98.0,4.6648422408241945,4 +FGD,100.0,4.646812620734046,4 +FGD,102.0,4.619446233097214,4 +FGD,104.0,4.601577591757871,4 +FGD,106.0,4.596426271732114,4 +FGD,108.0,4.563103670315502,4 +FGD,110.0,4.553605924018013,4 +FGD,112.0,4.551030264005135,4 +FGD,114.0,4.530585962652912,4 +FGD,116.0,4.5236638763683015,4 +FGD,118.0,4.515132002575642,4 +FGD,120.0,4.499678042498371,4 +FGD,2.0,97.98164842240824,5 +FGD,4.0,95.98905344494527,5 +FGD,6.0,93.99098518995494,5 +FGD,8.0,91.99581455247909,5 +FGD,10.0,89.98470701867353,5 +FGD,12.0,87.99919510624598,5 +FGD,14.0,85.9966194462331,5 +FGD,16.0,83.99887314874437,5 +FGD,18.0,81.99034127495172,5 +FGD,20.0,79.99533161622665,5 +FGD,22.0,77.99436574372183,5 +FGD,24.0,75.99468770122344,5 +FGD,26.0,73.99565357372826,5 +FGD,28.0,71.99983902124917,5 +FGD,30.0,69.9900193174501,5 +FGD,32.0,67.99468770122343,5 +FGD,34.0,65.9903412749517,5 +FGD,36.0,63.99468770122344,5 +FGD,38.0,61.993399871216994,5 +FGD,40.0,59.99130714745653,5 +FGD,42.0,57.99098518995493,5 +FGD,44.0,55.99356084996779,5 +FGD,46.0,53.99468770122342,5 +FGD,48.0,51.92289117836445,5 +FGD,50.0,49.988570508692845,5 +FGD,52.0,47.99983902124919,5 +FGD,54.0,45.92305215711525,5 +FGD,56.0,43.99806825499033,5 +FGD,58.0,41.99790727623952,5 +FGD,60.0,39.99018029620089,5 +FGD,62.0,37.94011590470057,5 +FGD,64.0,35.98792659368962,5 +FGD,66.0,33.99323889246618,5 +FGD,68.0,31.99404378622021,5 +FGD,70.0,29.9935608499678,5 +FGD,72.0,27.997424339987116,5 +FGD,74.0,25.99227301996136,5 +FGD,76.0,23.98985833869928,5 +FGD,78.0,21.91516419832581,5 +FGD,80.0,19.994204764971013,5 +FGD,82.0,17.99983902124918,5 +FGD,84.0,15.991468126207325,5 +FGD,86.0,13.98454603992272,5 +FGD,88.0,11.99130714745652,5 +FGD,90.0,9.987604636188006,5 +FGD,92.0,7.98808757244042,5 +FGD,94.0,5.990663232453298,5 +FGD,96.0,5.043947198969721,5 +FGD,98.0,5.037830006439135,5 +FGD,100.0,5.024951706374744,5 +FGD,102.0,5.007083065035401,5 +FGD,104.0,5.005312298776546,5 +FGD,106.0,5.002736638763667,5 +FGD,108.0,4.9966194462330815,5 +FGD,110.0,4.960560206052786,5 +FGD,112.0,4.9528332260141505,5 +FGD,114.0,4.921281390856391,5 +FGD,116.0,4.91435930457178,5 +FGD,118.0,4.90743721828717,5 +FGD,120.0,4.897939471989682,5 +FGD,2.0,97.98824855119122,6 +FGD,4.0,95.98551191242754,6 +FGD,6.0,93.99227301996136,6 +FGD,8.0,91.99645846748228,6 +FGD,10.0,89.94510624597554,6 +FGD,12.0,87.99388280746942,6 +FGD,14.0,85.99372182871862,6 +FGD,16.0,83.99565357372828,6 +FGD,18.0,81.98599484867998,6 +FGD,20.0,79.99774629748873,6 +FGD,22.0,77.98889246619446,6 +FGD,24.0,75.9935608499678,6 +FGD,26.0,73.99597553122987,6 +FGD,28.0,71.98422408242112,6 +FGD,30.0,69.98180940115905,6 +FGD,32.0,67.99227301996137,6 +FGD,34.0,65.99339987121701,6 +FGD,36.0,63.995170637475866,6 +FGD,38.0,61.99500965872505,6 +FGD,40.0,59.98390212491952,6 +FGD,42.0,57.99452672247264,6 +FGD,44.0,55.99645846748229,6 +FGD,46.0,53.98792659368963,6 +FGD,48.0,51.998390212491955,6 +FGD,50.0,49.99951706374758,6 +FGD,52.0,47.98921442369607,6 +FGD,54.0,45.99726336123632,6 +FGD,56.0,43.99388280746941,6 +FGD,58.0,41.99919510624597,6 +FGD,60.0,39.993399871216994,6 +FGD,62.0,37.995492594977456,6 +FGD,64.0,35.984707018673525,6 +FGD,66.0,33.9871216999356,6 +FGD,68.0,31.9871216999356,6 +FGD,70.0,29.984063103670305,6 +FGD,72.0,27.993077913715382,6 +FGD,74.0,25.994204764971013,6 +FGD,76.0,23.9937218287186,6 +FGD,78.0,21.998712169993553,6 +FGD,80.0,19.981165486155813,6 +FGD,82.0,17.996458467482277,6 +FGD,84.0,15.99678042498389,6 +FGD,86.0,13.996136509980667,6 +FGD,88.0,11.99822923374113,6 +FGD,90.0,9.99001931745008,6 +FGD,92.0,7.989375402446858,6 +FGD,94.0,5.914198325820974,6 +FGD,96.0,4.717160334835785,6 +FGD,98.0,4.702511268512539,6 +FGD,100.0,4.683515775917561,6 +FGD,102.0,4.652768834513825,6 +FGD,104.0,4.6410173857050685,6 +FGD,106.0,4.63844172569219,6 +FGD,108.0,4.630714745653555,6 +FGD,110.0,4.620412105602041,6 +FGD,112.0,4.615260785576285,6 +FGD,114.0,4.603187379265918,6 +FGD,116.0,4.595460399227283,6 +FGD,118.0,4.584352865421745,6 +FGD,120.0,4.563908564069523,6 +FGD,2.0,97.99533161622664,7 +FGD,4.0,95.99372182871858,7 +FGD,6.0,93.99951706374753,7 +FGD,8.0,91.99195106245972,7 +FGD,10.0,89.99275595621374,7 +FGD,12.0,87.9980682549903,7 +FGD,14.0,85.987604636188,7 +FGD,16.0,83.99388280746938,7 +FGD,18.0,81.98518995492591,7 +FGD,20.0,79.99549259497745,7 +FGD,22.0,77.99613650998069,7 +FGD,24.0,75.98969735994847,7 +FGD,26.0,73.98857050869285,7 +FGD,28.0,71.98567289117837,7 +FGD,30.0,69.99549259497746,7 +FGD,32.0,67.99661944623311,7 +FGD,34.0,65.99613650998069,7 +FGD,36.0,63.977945911139734,7 +FGD,38.0,61.98921442369608,7 +FGD,40.0,59.998551191242754,7 +FGD,42.0,57.99356084996781,7 +FGD,44.0,55.986155827430785,7 +FGD,46.0,53.96522858982614,7 +FGD,48.0,51.949935608499686,7 +FGD,50.0,49.9869607211848,7 +FGD,52.0,47.98454603992273,7 +FGD,54.0,45.973116548615586,7 +FGD,56.0,43.997746297488725,7 +FGD,58.0,41.990180296200904,7 +FGD,60.0,39.99887314874436,7 +FGD,62.0,37.99935608499677,7 +FGD,64.0,35.99822923374114,7 +FGD,66.0,33.99420476497102,7 +FGD,68.0,31.989697359948483,7 +FGD,70.0,29.98663876368319,7 +FGD,72.0,27.99195106245975,7 +FGD,74.0,25.996136509980676,7 +FGD,76.0,23.999839021249187,7 +FGD,78.0,21.992594977462968,7 +FGD,80.0,19.985672891178357,7 +FGD,82.0,17.984063103670305,7 +FGD,84.0,15.984707018673525,7 +FGD,86.0,13.997585318737912,7 +FGD,88.0,11.98760463618801,7 +FGD,90.0,9.98470701867352,7 +FGD,92.0,7.92916934964583,7 +FGD,94.0,5.996458467482277,7 +FGD,96.0,4.980038634900176,7 +FGD,98.0,4.946072118480343,7 +FGD,100.0,4.9280424983901945,7 +FGD,102.0,4.916934964584659,7 +FGD,104.0,4.898905344494512,7 +FGD,106.0,4.889407598197024,7 +FGD,108.0,4.8731487443657295,7 +FGD,110.0,4.870573084352852,7 +FGD,112.0,4.866226658081119,7 +FGD,114.0,4.861075338055362,7 +FGD,116.0,4.846426271732118,7 +FGD,118.0,4.832743077913702,7 +FGD,120.0,4.825820991629091,7 +FGD,2.0,97.98760463618798,8 +FGD,4.0,95.98792659368961,8 +FGD,6.0,93.98969735994847,8 +FGD,8.0,91.99500965872502,8 +FGD,10.0,89.99130714745652,8 +FGD,12.0,87.98502897617514,8 +FGD,14.0,85.99339987121698,8 +FGD,16.0,83.99597553122986,8 +FGD,18.0,81.99855119124274,8 +FGD,20.0,79.9967804249839,8 +FGD,22.0,77.99629748873149,8 +FGD,24.0,75.9905022537025,8 +FGD,26.0,73.99758531873792,8 +FGD,28.0,71.91870573084351,8 +FGD,30.0,69.99130714745652,8 +FGD,32.0,67.99066323245331,8 +FGD,34.0,65.99839021249194,8 +FGD,36.0,63.993560849967814,8 +FGD,38.0,61.98551191242756,8 +FGD,40.0,59.984063103670316,8 +FGD,42.0,57.98824855119125,8 +FGD,44.0,55.99951706374758,8 +FGD,46.0,53.92627173213136,8 +FGD,48.0,51.988731487443665,8 +FGD,50.0,49.87974887314875,8 +FGD,52.0,47.993721828718606,8 +FGD,54.0,45.98744365743722,8 +FGD,56.0,43.985833869929166,8 +FGD,58.0,41.99758531873793,8 +FGD,60.0,39.99742433998712,8 +FGD,62.0,37.99935608499678,8 +FGD,64.0,35.99822923374114,8 +FGD,66.0,33.98438506117192,8 +FGD,68.0,31.990502253702502,8 +FGD,70.0,29.998873148744355,8 +FGD,72.0,27.993077913715375,8 +FGD,74.0,25.99323889246618,8 +FGD,76.0,23.997907276239523,8 +FGD,78.0,21.99951706374757,8 +FGD,80.0,19.999839021249183,8 +FGD,82.0,17.973116548615565,8 +FGD,84.0,15.988731487443639,8 +FGD,86.0,13.990663232453295,8 +FGD,88.0,11.988409529942027,8 +FGD,90.0,9.997585318737908,8 +FGD,92.0,7.985833869929149,8 +FGD,94.0,6.123309723116526,8 +FGD,96.0,4.959755312298754,8 +FGD,98.0,4.957984546039902,8 +FGD,100.0,4.9333547971667535,8 +FGD,102.0,4.91548615582741,8 +FGD,104.0,4.890051513200238,8 +FGD,106.0,4.883129426915628,8 +FGD,108.0,4.878783000643897,8 +FGD,110.0,4.872826786864116,8 +FGD,112.0,4.865904700579505,8 +FGD,114.0,4.860753380553748,8 +FGD,116.0,4.855602060527993,8 +FGD,118.0,4.839504185447503,8 +FGD,120.0,4.834352865421747,8 +FGD,2.0,97.98486799742435,9 +FGD,4.0,95.99629748873147,9 +FGD,6.0,93.98470701867353,9 +FGD,8.0,91.98969735994848,9 +FGD,10.0,89.99227301996136,9 +FGD,12.0,87.99806825499033,9 +FGD,14.0,85.98647778493238,9 +FGD,16.0,83.99919510624598,9 +FGD,18.0,81.98857050869286,9 +FGD,20.0,79.98824855119125,9 +FGD,22.0,77.98905344494526,9 +FGD,24.0,75.99871216999357,9 +FGD,26.0,73.99420476497102,9 +FGD,28.0,71.99130714745652,9 +FGD,30.0,69.98502897617514,9 +FGD,32.0,67.99774629748873,9 +FGD,34.0,65.99211204121056,9 +FGD,36.0,63.98712169993562,9 +FGD,38.0,61.90148100450742,9 +FGD,40.0,59.9962974887315,9 +FGD,42.0,57.99919510624599,9 +FGD,44.0,55.99774629748874,9 +FGD,46.0,53.9932388924662,9 +FGD,48.0,51.977141017385705,9 +FGD,50.0,49.98390212491952,9 +FGD,52.0,47.97762395363813,9 +FGD,54.0,45.98985833869929,9 +FGD,56.0,43.99388280746941,9 +FGD,58.0,41.99179008370895,9 +FGD,60.0,39.99082421120412,9 +FGD,62.0,37.997102382485515,9 +FGD,64.0,35.988087572440435,9 +FGD,66.0,33.98840952994205,9 +FGD,68.0,31.995653573728262,9 +FGD,70.0,29.984385061171913,9 +FGD,72.0,27.9969414037347,9 +FGD,74.0,25.99420476497102,9 +FGD,76.0,23.99726336123631,9 +FGD,78.0,21.993077913715382,9 +FGD,80.0,19.995975531229874,9 +FGD,82.0,17.98905344494526,9 +FGD,84.0,15.997907276239529,9 +FGD,86.0,13.995653573728259,9 +FGD,88.0,11.996619446233089,9 +FGD,90.0,9.992273019961354,9 +FGD,92.0,7.99484867997423,9 +FGD,94.0,5.995009658725037,9 +FGD,96.0,4.792498390212476,9 +FGD,98.0,4.78605924018028,9 +FGD,100.0,4.751126851255617,9 +FGD,102.0,4.74855119124274,9 +FGD,104.0,4.74001931745008,9 +FGD,106.0,4.735672891178348,9 +FGD,108.0,4.71007726980037,9 +FGD,110.0,4.7020283322601255,9 +FGD,112.0,4.696877012234369,9 +FGD,114.0,4.6951062459755155,9 +FGD,116.0,4.682227945911124,9 +FGD,118.0,4.682227945911124,9 +FGD,120.0,4.682227945911124,9 diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/figure9b_occupied.csv b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9b_occupied.csv new file mode 100644 index 0000000..b08ed7f --- /dev/null +++ b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9b_occupied.csv @@ -0,0 +1,4201 @@ +scheduler,arrived_pct,occupied_nodes,run +Random,2.0,164,0 +Random,4.0,296,0 +Random,6.0,413,0 +Random,8.0,530,0 +Random,10.0,633,0 +Random,12.0,712,0 +Random,14.0,780,0 +Random,16.0,843,0 +Random,18.0,902,0 +Random,20.0,944,0 +Random,22.0,984,0 +Random,24.0,1021,0 +Random,26.0,1055,0 +Random,28.0,1083,0 +Random,30.0,1102,0 +Random,32.0,1120,0 +Random,34.0,1133,0 +Random,36.0,1145,0 +Random,38.0,1151,0 +Random,40.0,1167,0 +Random,42.0,1178,0 +Random,44.0,1185,0 +Random,46.0,1188,0 +Random,48.0,1191,0 +Random,50.0,1195,0 +Random,52.0,1201,0 +Random,54.0,1202,0 +Random,56.0,1204,0 +Random,58.0,1206,0 +Random,60.0,1208,0 +Random,62.0,1210,0 +Random,64.0,1211,0 +Random,66.0,1211,0 +Random,68.0,1211,0 +Random,70.0,1211,0 +Random,72.0,1212,0 +Random,74.0,1212,0 +Random,76.0,1212,0 +Random,78.0,1213,0 +Random,80.0,1213,0 +Random,82.0,1213,0 +Random,84.0,1213,0 +Random,86.0,1213,0 +Random,88.0,1213,0 +Random,90.0,1213,0 +Random,92.0,1213,0 +Random,94.0,1213,0 +Random,96.0,1213,0 +Random,98.0,1213,0 +Random,100.0,1213,0 +Random,102.0,1213,0 +Random,104.0,1213,0 +Random,106.0,1213,0 +Random,108.0,1213,0 +Random,110.0,1213,0 +Random,112.0,1213,0 +Random,114.0,1213,0 +Random,116.0,1213,0 +Random,118.0,1213,0 +Random,120.0,1213,0 +Random,2.0,167,1 +Random,4.0,295,1 +Random,6.0,422,1 +Random,8.0,517,1 +Random,10.0,610,1 +Random,12.0,691,1 +Random,14.0,772,1 +Random,16.0,838,1 +Random,18.0,891,1 +Random,20.0,933,1 +Random,22.0,969,1 +Random,24.0,1008,1 +Random,26.0,1033,1 +Random,28.0,1063,1 +Random,30.0,1092,1 +Random,32.0,1110,1 +Random,34.0,1134,1 +Random,36.0,1147,1 +Random,38.0,1159,1 +Random,40.0,1168,1 +Random,42.0,1171,1 +Random,44.0,1178,1 +Random,46.0,1187,1 +Random,48.0,1195,1 +Random,50.0,1202,1 +Random,52.0,1202,1 +Random,54.0,1205,1 +Random,56.0,1207,1 +Random,58.0,1207,1 +Random,60.0,1208,1 +Random,62.0,1209,1 +Random,64.0,1210,1 +Random,66.0,1210,1 +Random,68.0,1212,1 +Random,70.0,1213,1 +Random,72.0,1213,1 +Random,74.0,1213,1 +Random,76.0,1213,1 +Random,78.0,1213,1 +Random,80.0,1213,1 +Random,82.0,1213,1 +Random,84.0,1213,1 +Random,86.0,1213,1 +Random,88.0,1213,1 +Random,90.0,1213,1 +Random,92.0,1213,1 +Random,94.0,1213,1 +Random,96.0,1213,1 +Random,98.0,1213,1 +Random,100.0,1213,1 +Random,102.0,1213,1 +Random,104.0,1213,1 +Random,106.0,1213,1 +Random,108.0,1213,1 +Random,110.0,1213,1 +Random,112.0,1213,1 +Random,114.0,1213,1 +Random,116.0,1213,1 +Random,118.0,1213,1 +Random,120.0,1213,1 +Random,2.0,164,2 +Random,4.0,289,2 +Random,6.0,409,2 +Random,8.0,510,2 +Random,10.0,608,2 +Random,12.0,698,2 +Random,14.0,768,2 +Random,16.0,826,2 +Random,18.0,895,2 +Random,20.0,933,2 +Random,22.0,973,2 +Random,24.0,1008,2 +Random,26.0,1047,2 +Random,28.0,1071,2 +Random,30.0,1098,2 +Random,32.0,1113,2 +Random,34.0,1133,2 +Random,36.0,1147,2 +Random,38.0,1159,2 +Random,40.0,1169,2 +Random,42.0,1180,2 +Random,44.0,1187,2 +Random,46.0,1195,2 +Random,48.0,1197,2 +Random,50.0,1200,2 +Random,52.0,1206,2 +Random,54.0,1211,2 +Random,56.0,1211,2 +Random,58.0,1211,2 +Random,60.0,1211,2 +Random,62.0,1212,2 +Random,64.0,1212,2 +Random,66.0,1212,2 +Random,68.0,1213,2 +Random,70.0,1213,2 +Random,72.0,1213,2 +Random,74.0,1213,2 +Random,76.0,1213,2 +Random,78.0,1213,2 +Random,80.0,1213,2 +Random,82.0,1213,2 +Random,84.0,1213,2 +Random,86.0,1213,2 +Random,88.0,1213,2 +Random,90.0,1213,2 +Random,92.0,1213,2 +Random,94.0,1213,2 +Random,96.0,1213,2 +Random,98.0,1213,2 +Random,100.0,1213,2 +Random,102.0,1213,2 +Random,104.0,1213,2 +Random,106.0,1213,2 +Random,108.0,1213,2 +Random,110.0,1213,2 +Random,112.0,1213,2 +Random,114.0,1213,2 +Random,116.0,1213,2 +Random,118.0,1213,2 +Random,120.0,1213,2 +Random,2.0,161,3 +Random,4.0,310,3 +Random,6.0,427,3 +Random,8.0,541,3 +Random,10.0,633,3 +Random,12.0,708,3 +Random,14.0,788,3 +Random,16.0,847,3 +Random,18.0,896,3 +Random,20.0,942,3 +Random,22.0,974,3 +Random,24.0,1013,3 +Random,26.0,1042,3 +Random,28.0,1076,3 +Random,30.0,1103,3 +Random,32.0,1131,3 +Random,34.0,1144,3 +Random,36.0,1158,3 +Random,38.0,1170,3 +Random,40.0,1177,3 +Random,42.0,1185,3 +Random,44.0,1190,3 +Random,46.0,1195,3 +Random,48.0,1200,3 +Random,50.0,1205,3 +Random,52.0,1205,3 +Random,54.0,1207,3 +Random,56.0,1208,3 +Random,58.0,1208,3 +Random,60.0,1210,3 +Random,62.0,1211,3 +Random,64.0,1211,3 +Random,66.0,1212,3 +Random,68.0,1212,3 +Random,70.0,1213,3 +Random,72.0,1213,3 +Random,74.0,1213,3 +Random,76.0,1213,3 +Random,78.0,1213,3 +Random,80.0,1213,3 +Random,82.0,1213,3 +Random,84.0,1213,3 +Random,86.0,1213,3 +Random,88.0,1213,3 +Random,90.0,1213,3 +Random,92.0,1213,3 +Random,94.0,1213,3 +Random,96.0,1213,3 +Random,98.0,1213,3 +Random,100.0,1213,3 +Random,102.0,1213,3 +Random,104.0,1213,3 +Random,106.0,1213,3 +Random,108.0,1213,3 +Random,110.0,1213,3 +Random,112.0,1213,3 +Random,114.0,1213,3 +Random,116.0,1213,3 +Random,118.0,1213,3 +Random,120.0,1213,3 +Random,2.0,165,4 +Random,4.0,293,4 +Random,6.0,409,4 +Random,8.0,504,4 +Random,10.0,602,4 +Random,12.0,685,4 +Random,14.0,763,4 +Random,16.0,822,4 +Random,18.0,879,4 +Random,20.0,936,4 +Random,22.0,970,4 +Random,24.0,1005,4 +Random,26.0,1033,4 +Random,28.0,1045,4 +Random,30.0,1074,4 +Random,32.0,1096,4 +Random,34.0,1116,4 +Random,36.0,1137,4 +Random,38.0,1154,4 +Random,40.0,1169,4 +Random,42.0,1179,4 +Random,44.0,1186,4 +Random,46.0,1190,4 +Random,48.0,1196,4 +Random,50.0,1199,4 +Random,52.0,1202,4 +Random,54.0,1205,4 +Random,56.0,1206,4 +Random,58.0,1209,4 +Random,60.0,1211,4 +Random,62.0,1211,4 +Random,64.0,1211,4 +Random,66.0,1211,4 +Random,68.0,1212,4 +Random,70.0,1212,4 +Random,72.0,1212,4 +Random,74.0,1212,4 +Random,76.0,1212,4 +Random,78.0,1212,4 +Random,80.0,1212,4 +Random,82.0,1213,4 +Random,84.0,1213,4 +Random,86.0,1213,4 +Random,88.0,1213,4 +Random,90.0,1213,4 +Random,92.0,1213,4 +Random,94.0,1213,4 +Random,96.0,1213,4 +Random,98.0,1213,4 +Random,100.0,1213,4 +Random,102.0,1213,4 +Random,104.0,1213,4 +Random,106.0,1213,4 +Random,108.0,1213,4 +Random,110.0,1213,4 +Random,112.0,1213,4 +Random,114.0,1213,4 +Random,116.0,1213,4 +Random,118.0,1213,4 +Random,120.0,1213,4 +Random,2.0,158,5 +Random,4.0,304,5 +Random,6.0,421,5 +Random,8.0,521,5 +Random,10.0,617,5 +Random,12.0,700,5 +Random,14.0,778,5 +Random,16.0,851,5 +Random,18.0,903,5 +Random,20.0,957,5 +Random,22.0,999,5 +Random,24.0,1025,5 +Random,26.0,1060,5 +Random,28.0,1078,5 +Random,30.0,1102,5 +Random,32.0,1122,5 +Random,34.0,1143,5 +Random,36.0,1154,5 +Random,38.0,1172,5 +Random,40.0,1181,5 +Random,42.0,1188,5 +Random,44.0,1191,5 +Random,46.0,1195,5 +Random,48.0,1199,5 +Random,50.0,1202,5 +Random,52.0,1206,5 +Random,54.0,1206,5 +Random,56.0,1208,5 +Random,58.0,1209,5 +Random,60.0,1210,5 +Random,62.0,1212,5 +Random,64.0,1212,5 +Random,66.0,1212,5 +Random,68.0,1212,5 +Random,70.0,1212,5 +Random,72.0,1212,5 +Random,74.0,1212,5 +Random,76.0,1212,5 +Random,78.0,1212,5 +Random,80.0,1212,5 +Random,82.0,1213,5 +Random,84.0,1213,5 +Random,86.0,1213,5 +Random,88.0,1213,5 +Random,90.0,1213,5 +Random,92.0,1213,5 +Random,94.0,1213,5 +Random,96.0,1213,5 +Random,98.0,1213,5 +Random,100.0,1213,5 +Random,102.0,1213,5 +Random,104.0,1213,5 +Random,106.0,1213,5 +Random,108.0,1213,5 +Random,110.0,1213,5 +Random,112.0,1213,5 +Random,114.0,1213,5 +Random,116.0,1213,5 +Random,118.0,1213,5 +Random,120.0,1213,5 +Random,2.0,152,6 +Random,4.0,302,6 +Random,6.0,410,6 +Random,8.0,512,6 +Random,10.0,612,6 +Random,12.0,686,6 +Random,14.0,756,6 +Random,16.0,822,6 +Random,18.0,873,6 +Random,20.0,924,6 +Random,22.0,972,6 +Random,24.0,1013,6 +Random,26.0,1044,6 +Random,28.0,1072,6 +Random,30.0,1089,6 +Random,32.0,1107,6 +Random,34.0,1125,6 +Random,36.0,1142,6 +Random,38.0,1153,6 +Random,40.0,1164,6 +Random,42.0,1178,6 +Random,44.0,1184,6 +Random,46.0,1190,6 +Random,48.0,1196,6 +Random,50.0,1203,6 +Random,52.0,1205,6 +Random,54.0,1207,6 +Random,56.0,1208,6 +Random,58.0,1209,6 +Random,60.0,1212,6 +Random,62.0,1212,6 +Random,64.0,1213,6 +Random,66.0,1213,6 +Random,68.0,1213,6 +Random,70.0,1213,6 +Random,72.0,1213,6 +Random,74.0,1213,6 +Random,76.0,1213,6 +Random,78.0,1213,6 +Random,80.0,1213,6 +Random,82.0,1213,6 +Random,84.0,1213,6 +Random,86.0,1213,6 +Random,88.0,1213,6 +Random,90.0,1213,6 +Random,92.0,1213,6 +Random,94.0,1213,6 +Random,96.0,1213,6 +Random,98.0,1213,6 +Random,100.0,1213,6 +Random,102.0,1213,6 +Random,104.0,1213,6 +Random,106.0,1213,6 +Random,108.0,1213,6 +Random,110.0,1213,6 +Random,112.0,1213,6 +Random,114.0,1213,6 +Random,116.0,1213,6 +Random,118.0,1213,6 +Random,120.0,1213,6 +Random,2.0,151,7 +Random,4.0,280,7 +Random,6.0,401,7 +Random,8.0,515,7 +Random,10.0,607,7 +Random,12.0,678,7 +Random,14.0,755,7 +Random,16.0,825,7 +Random,18.0,883,7 +Random,20.0,930,7 +Random,22.0,979,7 +Random,24.0,1020,7 +Random,26.0,1049,7 +Random,28.0,1079,7 +Random,30.0,1100,7 +Random,32.0,1117,7 +Random,34.0,1140,7 +Random,36.0,1160,7 +Random,38.0,1171,7 +Random,40.0,1179,7 +Random,42.0,1184,7 +Random,44.0,1191,7 +Random,46.0,1200,7 +Random,48.0,1204,7 +Random,50.0,1208,7 +Random,52.0,1209,7 +Random,54.0,1210,7 +Random,56.0,1210,7 +Random,58.0,1211,7 +Random,60.0,1211,7 +Random,62.0,1211,7 +Random,64.0,1211,7 +Random,66.0,1211,7 +Random,68.0,1211,7 +Random,70.0,1212,7 +Random,72.0,1213,7 +Random,74.0,1213,7 +Random,76.0,1213,7 +Random,78.0,1213,7 +Random,80.0,1213,7 +Random,82.0,1213,7 +Random,84.0,1213,7 +Random,86.0,1213,7 +Random,88.0,1213,7 +Random,90.0,1213,7 +Random,92.0,1213,7 +Random,94.0,1213,7 +Random,96.0,1213,7 +Random,98.0,1213,7 +Random,100.0,1213,7 +Random,102.0,1213,7 +Random,104.0,1213,7 +Random,106.0,1213,7 +Random,108.0,1213,7 +Random,110.0,1213,7 +Random,112.0,1213,7 +Random,114.0,1213,7 +Random,116.0,1213,7 +Random,118.0,1213,7 +Random,120.0,1213,7 +Random,2.0,158,8 +Random,4.0,283,8 +Random,6.0,404,8 +Random,8.0,516,8 +Random,10.0,619,8 +Random,12.0,695,8 +Random,14.0,775,8 +Random,16.0,832,8 +Random,18.0,892,8 +Random,20.0,937,8 +Random,22.0,983,8 +Random,24.0,1016,8 +Random,26.0,1038,8 +Random,28.0,1067,8 +Random,30.0,1099,8 +Random,32.0,1118,8 +Random,34.0,1136,8 +Random,36.0,1147,8 +Random,38.0,1158,8 +Random,40.0,1167,8 +Random,42.0,1174,8 +Random,44.0,1180,8 +Random,46.0,1187,8 +Random,48.0,1191,8 +Random,50.0,1195,8 +Random,52.0,1196,8 +Random,54.0,1199,8 +Random,56.0,1203,8 +Random,58.0,1204,8 +Random,60.0,1209,8 +Random,62.0,1210,8 +Random,64.0,1210,8 +Random,66.0,1210,8 +Random,68.0,1210,8 +Random,70.0,1211,8 +Random,72.0,1212,8 +Random,74.0,1212,8 +Random,76.0,1212,8 +Random,78.0,1212,8 +Random,80.0,1212,8 +Random,82.0,1213,8 +Random,84.0,1213,8 +Random,86.0,1213,8 +Random,88.0,1213,8 +Random,90.0,1213,8 +Random,92.0,1213,8 +Random,94.0,1213,8 +Random,96.0,1213,8 +Random,98.0,1213,8 +Random,100.0,1213,8 +Random,102.0,1213,8 +Random,104.0,1213,8 +Random,106.0,1213,8 +Random,108.0,1213,8 +Random,110.0,1213,8 +Random,112.0,1213,8 +Random,114.0,1213,8 +Random,116.0,1213,8 +Random,118.0,1213,8 +Random,120.0,1213,8 +Random,2.0,161,9 +Random,4.0,306,9 +Random,6.0,429,9 +Random,8.0,528,9 +Random,10.0,620,9 +Random,12.0,704,9 +Random,14.0,780,9 +Random,16.0,843,9 +Random,18.0,898,9 +Random,20.0,946,9 +Random,22.0,988,9 +Random,24.0,1020,9 +Random,26.0,1048,9 +Random,28.0,1079,9 +Random,30.0,1098,9 +Random,32.0,1121,9 +Random,34.0,1138,9 +Random,36.0,1152,9 +Random,38.0,1161,9 +Random,40.0,1170,9 +Random,42.0,1177,9 +Random,44.0,1180,9 +Random,46.0,1190,9 +Random,48.0,1197,9 +Random,50.0,1201,9 +Random,52.0,1203,9 +Random,54.0,1207,9 +Random,56.0,1207,9 +Random,58.0,1209,9 +Random,60.0,1209,9 +Random,62.0,1210,9 +Random,64.0,1210,9 +Random,66.0,1211,9 +Random,68.0,1211,9 +Random,70.0,1212,9 +Random,72.0,1212,9 +Random,74.0,1213,9 +Random,76.0,1213,9 +Random,78.0,1213,9 +Random,80.0,1213,9 +Random,82.0,1213,9 +Random,84.0,1213,9 +Random,86.0,1213,9 +Random,88.0,1213,9 +Random,90.0,1213,9 +Random,92.0,1213,9 +Random,94.0,1213,9 +Random,96.0,1213,9 +Random,98.0,1213,9 +Random,100.0,1213,9 +Random,102.0,1213,9 +Random,104.0,1213,9 +Random,106.0,1213,9 +Random,108.0,1213,9 +Random,110.0,1213,9 +Random,112.0,1213,9 +Random,114.0,1213,9 +Random,116.0,1213,9 +Random,118.0,1213,9 +Random,120.0,1213,9 +BestFit,2.0,109,0 +BestFit,4.0,170,0 +BestFit,6.0,217,0 +BestFit,8.0,282,0 +BestFit,10.0,348,0 +BestFit,12.0,413,0 +BestFit,14.0,475,0 +BestFit,16.0,531,0 +BestFit,18.0,588,0 +BestFit,20.0,613,0 +BestFit,22.0,630,0 +BestFit,24.0,646,0 +BestFit,26.0,662,0 +BestFit,28.0,678,0 +BestFit,30.0,695,0 +BestFit,32.0,711,0 +BestFit,34.0,727,0 +BestFit,36.0,744,0 +BestFit,38.0,761,0 +BestFit,40.0,777,0 +BestFit,42.0,794,0 +BestFit,44.0,811,0 +BestFit,46.0,827,0 +BestFit,48.0,844,0 +BestFit,50.0,860,0 +BestFit,52.0,877,0 +BestFit,54.0,893,0 +BestFit,56.0,909,0 +BestFit,58.0,926,0 +BestFit,60.0,942,0 +BestFit,62.0,958,0 +BestFit,64.0,975,0 +BestFit,66.0,991,0 +BestFit,68.0,1008,0 +BestFit,70.0,1024,0 +BestFit,72.0,1041,0 +BestFit,74.0,1058,0 +BestFit,76.0,1074,0 +BestFit,78.0,1090,0 +BestFit,80.0,1107,0 +BestFit,82.0,1123,0 +BestFit,84.0,1140,0 +BestFit,86.0,1156,0 +BestFit,88.0,1172,0 +BestFit,90.0,1189,0 +BestFit,92.0,1205,0 +BestFit,94.0,1213,0 +BestFit,96.0,1213,0 +BestFit,98.0,1213,0 +BestFit,100.0,1213,0 +BestFit,102.0,1213,0 +BestFit,104.0,1213,0 +BestFit,106.0,1213,0 +BestFit,108.0,1213,0 +BestFit,110.0,1213,0 +BestFit,112.0,1213,0 +BestFit,114.0,1213,0 +BestFit,116.0,1213,0 +BestFit,118.0,1213,0 +BestFit,120.0,1213,0 +BestFit,2.0,111,1 +BestFit,4.0,170,1 +BestFit,6.0,228,1 +BestFit,8.0,290,1 +BestFit,10.0,350,1 +BestFit,12.0,409,1 +BestFit,14.0,470,1 +BestFit,16.0,534,1 +BestFit,18.0,593,1 +BestFit,20.0,616,1 +BestFit,22.0,632,1 +BestFit,24.0,649,1 +BestFit,26.0,665,1 +BestFit,28.0,682,1 +BestFit,30.0,699,1 +BestFit,32.0,715,1 +BestFit,34.0,731,1 +BestFit,36.0,747,1 +BestFit,38.0,764,1 +BestFit,40.0,780,1 +BestFit,42.0,796,1 +BestFit,44.0,813,1 +BestFit,46.0,829,1 +BestFit,48.0,845,1 +BestFit,50.0,863,1 +BestFit,52.0,878,1 +BestFit,54.0,895,1 +BestFit,56.0,911,1 +BestFit,58.0,927,1 +BestFit,60.0,944,1 +BestFit,62.0,960,1 +BestFit,64.0,977,1 +BestFit,66.0,993,1 +BestFit,68.0,1010,1 +BestFit,70.0,1026,1 +BestFit,72.0,1042,1 +BestFit,74.0,1058,1 +BestFit,76.0,1075,1 +BestFit,78.0,1091,1 +BestFit,80.0,1108,1 +BestFit,82.0,1124,1 +BestFit,84.0,1141,1 +BestFit,86.0,1157,1 +BestFit,88.0,1173,1 +BestFit,90.0,1190,1 +BestFit,92.0,1206,1 +BestFit,94.0,1213,1 +BestFit,96.0,1213,1 +BestFit,98.0,1213,1 +BestFit,100.0,1213,1 +BestFit,102.0,1213,1 +BestFit,104.0,1213,1 +BestFit,106.0,1213,1 +BestFit,108.0,1213,1 +BestFit,110.0,1213,1 +BestFit,112.0,1213,1 +BestFit,114.0,1213,1 +BestFit,116.0,1213,1 +BestFit,118.0,1213,1 +BestFit,120.0,1213,1 +BestFit,2.0,112,2 +BestFit,4.0,168,2 +BestFit,6.0,210,2 +BestFit,8.0,275,2 +BestFit,10.0,337,2 +BestFit,12.0,401,2 +BestFit,14.0,464,2 +BestFit,16.0,519,2 +BestFit,18.0,581,2 +BestFit,20.0,614,2 +BestFit,22.0,630,2 +BestFit,24.0,646,2 +BestFit,26.0,663,2 +BestFit,28.0,679,2 +BestFit,30.0,696,2 +BestFit,32.0,712,2 +BestFit,34.0,728,2 +BestFit,36.0,745,2 +BestFit,38.0,761,2 +BestFit,40.0,778,2 +BestFit,42.0,795,2 +BestFit,44.0,811,2 +BestFit,46.0,828,2 +BestFit,48.0,844,2 +BestFit,50.0,861,2 +BestFit,52.0,878,2 +BestFit,54.0,894,2 +BestFit,56.0,911,2 +BestFit,58.0,927,2 +BestFit,60.0,944,2 +BestFit,62.0,960,2 +BestFit,64.0,977,2 +BestFit,66.0,993,2 +BestFit,68.0,1010,2 +BestFit,70.0,1026,2 +BestFit,72.0,1043,2 +BestFit,74.0,1060,2 +BestFit,76.0,1076,2 +BestFit,78.0,1093,2 +BestFit,80.0,1109,2 +BestFit,82.0,1126,2 +BestFit,84.0,1142,2 +BestFit,86.0,1158,2 +BestFit,88.0,1175,2 +BestFit,90.0,1191,2 +BestFit,92.0,1207,2 +BestFit,94.0,1213,2 +BestFit,96.0,1213,2 +BestFit,98.0,1213,2 +BestFit,100.0,1213,2 +BestFit,102.0,1213,2 +BestFit,104.0,1213,2 +BestFit,106.0,1213,2 +BestFit,108.0,1213,2 +BestFit,110.0,1213,2 +BestFit,112.0,1213,2 +BestFit,114.0,1213,2 +BestFit,116.0,1213,2 +BestFit,118.0,1213,2 +BestFit,120.0,1213,2 +BestFit,2.0,101,3 +BestFit,4.0,170,3 +BestFit,6.0,224,3 +BestFit,8.0,289,3 +BestFit,10.0,352,3 +BestFit,12.0,414,3 +BestFit,14.0,479,3 +BestFit,16.0,546,3 +BestFit,18.0,598,3 +BestFit,20.0,616,3 +BestFit,22.0,633,3 +BestFit,24.0,649,3 +BestFit,26.0,665,3 +BestFit,28.0,682,3 +BestFit,30.0,698,3 +BestFit,32.0,715,3 +BestFit,34.0,731,3 +BestFit,36.0,748,3 +BestFit,38.0,765,3 +BestFit,40.0,781,3 +BestFit,42.0,797,3 +BestFit,44.0,813,3 +BestFit,46.0,830,3 +BestFit,48.0,846,3 +BestFit,50.0,862,3 +BestFit,52.0,879,3 +BestFit,54.0,896,3 +BestFit,56.0,912,3 +BestFit,58.0,929,3 +BestFit,60.0,945,3 +BestFit,62.0,962,3 +BestFit,64.0,979,3 +BestFit,66.0,995,3 +BestFit,68.0,1012,3 +BestFit,70.0,1029,3 +BestFit,72.0,1045,3 +BestFit,74.0,1061,3 +BestFit,76.0,1078,3 +BestFit,78.0,1094,3 +BestFit,80.0,1111,3 +BestFit,82.0,1128,3 +BestFit,84.0,1144,3 +BestFit,86.0,1161,3 +BestFit,88.0,1177,3 +BestFit,90.0,1193,3 +BestFit,92.0,1209,3 +BestFit,94.0,1213,3 +BestFit,96.0,1213,3 +BestFit,98.0,1213,3 +BestFit,100.0,1213,3 +BestFit,102.0,1213,3 +BestFit,104.0,1213,3 +BestFit,106.0,1213,3 +BestFit,108.0,1213,3 +BestFit,110.0,1213,3 +BestFit,112.0,1213,3 +BestFit,114.0,1213,3 +BestFit,116.0,1213,3 +BestFit,118.0,1213,3 +BestFit,120.0,1213,3 +BestFit,2.0,107,4 +BestFit,4.0,166,4 +BestFit,6.0,214,4 +BestFit,8.0,276,4 +BestFit,10.0,337,4 +BestFit,12.0,399,4 +BestFit,14.0,459,4 +BestFit,16.0,521,4 +BestFit,18.0,583,4 +BestFit,20.0,616,4 +BestFit,22.0,632,4 +BestFit,24.0,648,4 +BestFit,26.0,665,4 +BestFit,28.0,681,4 +BestFit,30.0,697,4 +BestFit,32.0,714,4 +BestFit,34.0,730,4 +BestFit,36.0,747,4 +BestFit,38.0,763,4 +BestFit,40.0,779,4 +BestFit,42.0,796,4 +BestFit,44.0,812,4 +BestFit,46.0,828,4 +BestFit,48.0,844,4 +BestFit,50.0,861,4 +BestFit,52.0,878,4 +BestFit,54.0,894,4 +BestFit,56.0,911,4 +BestFit,58.0,927,4 +BestFit,60.0,943,4 +BestFit,62.0,960,4 +BestFit,64.0,976,4 +BestFit,66.0,993,4 +BestFit,68.0,1009,4 +BestFit,70.0,1025,4 +BestFit,72.0,1042,4 +BestFit,74.0,1058,4 +BestFit,76.0,1075,4 +BestFit,78.0,1092,4 +BestFit,80.0,1108,4 +BestFit,82.0,1125,4 +BestFit,84.0,1141,4 +BestFit,86.0,1157,4 +BestFit,88.0,1174,4 +BestFit,90.0,1190,4 +BestFit,92.0,1206,4 +BestFit,94.0,1213,4 +BestFit,96.0,1213,4 +BestFit,98.0,1213,4 +BestFit,100.0,1213,4 +BestFit,102.0,1213,4 +BestFit,104.0,1213,4 +BestFit,106.0,1213,4 +BestFit,108.0,1213,4 +BestFit,110.0,1213,4 +BestFit,112.0,1213,4 +BestFit,114.0,1213,4 +BestFit,116.0,1213,4 +BestFit,118.0,1213,4 +BestFit,120.0,1213,4 +BestFit,2.0,108,5 +BestFit,4.0,169,5 +BestFit,6.0,214,5 +BestFit,8.0,277,5 +BestFit,10.0,339,5 +BestFit,12.0,397,5 +BestFit,14.0,461,5 +BestFit,16.0,524,5 +BestFit,18.0,586,5 +BestFit,20.0,613,5 +BestFit,22.0,629,5 +BestFit,24.0,646,5 +BestFit,26.0,662,5 +BestFit,28.0,679,5 +BestFit,30.0,695,5 +BestFit,32.0,711,5 +BestFit,34.0,728,5 +BestFit,36.0,745,5 +BestFit,38.0,762,5 +BestFit,40.0,778,5 +BestFit,42.0,795,5 +BestFit,44.0,812,5 +BestFit,46.0,828,5 +BestFit,48.0,845,5 +BestFit,50.0,861,5 +BestFit,52.0,877,5 +BestFit,54.0,894,5 +BestFit,56.0,910,5 +BestFit,58.0,927,5 +BestFit,60.0,943,5 +BestFit,62.0,959,5 +BestFit,64.0,976,5 +BestFit,66.0,992,5 +BestFit,68.0,1008,5 +BestFit,70.0,1025,5 +BestFit,72.0,1041,5 +BestFit,74.0,1058,5 +BestFit,76.0,1074,5 +BestFit,78.0,1091,5 +BestFit,80.0,1107,5 +BestFit,82.0,1123,5 +BestFit,84.0,1140,5 +BestFit,86.0,1157,5 +BestFit,88.0,1173,5 +BestFit,90.0,1190,5 +BestFit,92.0,1206,5 +BestFit,94.0,1213,5 +BestFit,96.0,1213,5 +BestFit,98.0,1213,5 +BestFit,100.0,1213,5 +BestFit,102.0,1213,5 +BestFit,104.0,1213,5 +BestFit,106.0,1213,5 +BestFit,108.0,1213,5 +BestFit,110.0,1213,5 +BestFit,112.0,1213,5 +BestFit,114.0,1213,5 +BestFit,116.0,1213,5 +BestFit,118.0,1213,5 +BestFit,120.0,1213,5 +BestFit,2.0,117,6 +BestFit,4.0,175,6 +BestFit,6.0,220,6 +BestFit,8.0,276,6 +BestFit,10.0,338,6 +BestFit,12.0,399,6 +BestFit,14.0,464,6 +BestFit,16.0,525,6 +BestFit,18.0,582,6 +BestFit,20.0,614,6 +BestFit,22.0,630,6 +BestFit,24.0,646,6 +BestFit,26.0,662,6 +BestFit,28.0,679,6 +BestFit,30.0,695,6 +BestFit,32.0,712,6 +BestFit,34.0,729,6 +BestFit,36.0,745,6 +BestFit,38.0,761,6 +BestFit,40.0,778,6 +BestFit,42.0,794,6 +BestFit,44.0,810,6 +BestFit,46.0,827,6 +BestFit,48.0,844,6 +BestFit,50.0,860,6 +BestFit,52.0,877,6 +BestFit,54.0,893,6 +BestFit,56.0,910,6 +BestFit,58.0,926,6 +BestFit,60.0,943,6 +BestFit,62.0,960,6 +BestFit,64.0,976,6 +BestFit,66.0,993,6 +BestFit,68.0,1009,6 +BestFit,70.0,1025,6 +BestFit,72.0,1041,6 +BestFit,74.0,1058,6 +BestFit,76.0,1074,6 +BestFit,78.0,1091,6 +BestFit,80.0,1107,6 +BestFit,82.0,1124,6 +BestFit,84.0,1140,6 +BestFit,86.0,1156,6 +BestFit,88.0,1173,6 +BestFit,90.0,1189,6 +BestFit,92.0,1205,6 +BestFit,94.0,1213,6 +BestFit,96.0,1213,6 +BestFit,98.0,1213,6 +BestFit,100.0,1213,6 +BestFit,102.0,1213,6 +BestFit,104.0,1213,6 +BestFit,106.0,1213,6 +BestFit,108.0,1213,6 +BestFit,110.0,1213,6 +BestFit,112.0,1213,6 +BestFit,114.0,1213,6 +BestFit,116.0,1213,6 +BestFit,118.0,1213,6 +BestFit,120.0,1213,6 +BestFit,2.0,104,7 +BestFit,4.0,166,7 +BestFit,6.0,207,7 +BestFit,8.0,272,7 +BestFit,10.0,337,7 +BestFit,12.0,398,7 +BestFit,14.0,464,7 +BestFit,16.0,528,7 +BestFit,18.0,590,7 +BestFit,20.0,614,7 +BestFit,22.0,630,7 +BestFit,24.0,647,7 +BestFit,26.0,664,7 +BestFit,28.0,680,7 +BestFit,30.0,696,7 +BestFit,32.0,713,7 +BestFit,34.0,729,7 +BestFit,36.0,746,7 +BestFit,38.0,762,7 +BestFit,40.0,778,7 +BestFit,42.0,795,7 +BestFit,44.0,811,7 +BestFit,46.0,828,7 +BestFit,48.0,844,7 +BestFit,50.0,860,7 +BestFit,52.0,877,7 +BestFit,54.0,894,7 +BestFit,56.0,910,7 +BestFit,58.0,927,7 +BestFit,60.0,943,7 +BestFit,62.0,960,7 +BestFit,64.0,976,7 +BestFit,66.0,993,7 +BestFit,68.0,1010,7 +BestFit,70.0,1026,7 +BestFit,72.0,1042,7 +BestFit,74.0,1059,7 +BestFit,76.0,1076,7 +BestFit,78.0,1092,7 +BestFit,80.0,1109,7 +BestFit,82.0,1125,7 +BestFit,84.0,1142,7 +BestFit,86.0,1158,7 +BestFit,88.0,1174,7 +BestFit,90.0,1190,7 +BestFit,92.0,1207,7 +BestFit,94.0,1213,7 +BestFit,96.0,1213,7 +BestFit,98.0,1213,7 +BestFit,100.0,1213,7 +BestFit,102.0,1213,7 +BestFit,104.0,1213,7 +BestFit,106.0,1213,7 +BestFit,108.0,1213,7 +BestFit,110.0,1213,7 +BestFit,112.0,1213,7 +BestFit,114.0,1213,7 +BestFit,116.0,1213,7 +BestFit,118.0,1213,7 +BestFit,120.0,1213,7 +BestFit,2.0,109,8 +BestFit,4.0,166,8 +BestFit,6.0,215,8 +BestFit,8.0,277,8 +BestFit,10.0,339,8 +BestFit,12.0,401,8 +BestFit,14.0,461,8 +BestFit,16.0,519,8 +BestFit,18.0,583,8 +BestFit,20.0,613,8 +BestFit,22.0,629,8 +BestFit,24.0,646,8 +BestFit,26.0,662,8 +BestFit,28.0,679,8 +BestFit,30.0,695,8 +BestFit,32.0,711,8 +BestFit,34.0,728,8 +BestFit,36.0,745,8 +BestFit,38.0,761,8 +BestFit,40.0,778,8 +BestFit,42.0,794,8 +BestFit,44.0,810,8 +BestFit,46.0,827,8 +BestFit,48.0,843,8 +BestFit,50.0,860,8 +BestFit,52.0,876,8 +BestFit,54.0,892,8 +BestFit,56.0,908,8 +BestFit,58.0,924,8 +BestFit,60.0,940,8 +BestFit,62.0,957,8 +BestFit,64.0,974,8 +BestFit,66.0,990,8 +BestFit,68.0,1006,8 +BestFit,70.0,1023,8 +BestFit,72.0,1039,8 +BestFit,74.0,1055,8 +BestFit,76.0,1072,8 +BestFit,78.0,1088,8 +BestFit,80.0,1105,8 +BestFit,82.0,1121,8 +BestFit,84.0,1137,8 +BestFit,86.0,1153,8 +BestFit,88.0,1170,8 +BestFit,90.0,1186,8 +BestFit,92.0,1202,8 +BestFit,94.0,1213,8 +BestFit,96.0,1213,8 +BestFit,98.0,1213,8 +BestFit,100.0,1213,8 +BestFit,102.0,1213,8 +BestFit,104.0,1213,8 +BestFit,106.0,1213,8 +BestFit,108.0,1213,8 +BestFit,110.0,1213,8 +BestFit,112.0,1213,8 +BestFit,114.0,1213,8 +BestFit,116.0,1213,8 +BestFit,118.0,1213,8 +BestFit,120.0,1213,8 +BestFit,2.0,115,9 +BestFit,4.0,175,9 +BestFit,6.0,219,9 +BestFit,8.0,276,9 +BestFit,10.0,334,9 +BestFit,12.0,394,9 +BestFit,14.0,452,9 +BestFit,16.0,517,9 +BestFit,18.0,580,9 +BestFit,20.0,614,9 +BestFit,22.0,630,9 +BestFit,24.0,646,9 +BestFit,26.0,663,9 +BestFit,28.0,679,9 +BestFit,30.0,696,9 +BestFit,32.0,712,9 +BestFit,34.0,729,9 +BestFit,36.0,745,9 +BestFit,38.0,762,9 +BestFit,40.0,778,9 +BestFit,42.0,795,9 +BestFit,44.0,811,9 +BestFit,46.0,828,9 +BestFit,48.0,845,9 +BestFit,50.0,861,9 +BestFit,52.0,877,9 +BestFit,54.0,894,9 +BestFit,56.0,910,9 +BestFit,58.0,926,9 +BestFit,60.0,943,9 +BestFit,62.0,959,9 +BestFit,64.0,976,9 +BestFit,66.0,992,9 +BestFit,68.0,1009,9 +BestFit,70.0,1026,9 +BestFit,72.0,1042,9 +BestFit,74.0,1059,9 +BestFit,76.0,1075,9 +BestFit,78.0,1092,9 +BestFit,80.0,1108,9 +BestFit,82.0,1124,9 +BestFit,84.0,1141,9 +BestFit,86.0,1157,9 +BestFit,88.0,1174,9 +BestFit,90.0,1190,9 +BestFit,92.0,1205,9 +BestFit,94.0,1213,9 +BestFit,96.0,1213,9 +BestFit,98.0,1213,9 +BestFit,100.0,1213,9 +BestFit,102.0,1213,9 +BestFit,104.0,1213,9 +BestFit,106.0,1213,9 +BestFit,108.0,1213,9 +BestFit,110.0,1213,9 +BestFit,112.0,1213,9 +BestFit,114.0,1213,9 +BestFit,116.0,1213,9 +BestFit,118.0,1213,9 +BestFit,120.0,1213,9 +BestFit-PN,2.0,34,0 +BestFit-PN,4.0,53,0 +BestFit-PN,6.0,76,0 +BestFit-PN,8.0,97,0 +BestFit-PN,10.0,117,0 +BestFit-PN,12.0,153,0 +BestFit-PN,14.0,174,0 +BestFit-PN,16.0,193,0 +BestFit-PN,18.0,224,0 +BestFit-PN,20.0,250,0 +BestFit-PN,22.0,274,0 +BestFit-PN,24.0,295,0 +BestFit-PN,26.0,322,0 +BestFit-PN,28.0,340,0 +BestFit-PN,30.0,360,0 +BestFit-PN,32.0,384,0 +BestFit-PN,34.0,412,0 +BestFit-PN,36.0,444,0 +BestFit-PN,38.0,468,0 +BestFit-PN,40.0,494,0 +BestFit-PN,42.0,513,0 +BestFit-PN,44.0,533,0 +BestFit-PN,46.0,561,0 +BestFit-PN,48.0,586,0 +BestFit-PN,50.0,624,0 +BestFit-PN,52.0,661,0 +BestFit-PN,54.0,680,0 +BestFit-PN,56.0,713,0 +BestFit-PN,58.0,746,0 +BestFit-PN,60.0,779,0 +BestFit-PN,62.0,802,0 +BestFit-PN,64.0,819,0 +BestFit-PN,66.0,836,0 +BestFit-PN,68.0,857,0 +BestFit-PN,70.0,889,0 +BestFit-PN,72.0,912,0 +BestFit-PN,74.0,934,0 +BestFit-PN,76.0,961,0 +BestFit-PN,78.0,982,0 +BestFit-PN,80.0,1007,0 +BestFit-PN,82.0,1031,0 +BestFit-PN,84.0,1052,0 +BestFit-PN,86.0,1083,0 +BestFit-PN,88.0,1111,0 +BestFit-PN,90.0,1149,0 +BestFit-PN,92.0,1189,0 +BestFit-PN,94.0,1213,0 +BestFit-PN,96.0,1213,0 +BestFit-PN,98.0,1213,0 +BestFit-PN,100.0,1213,0 +BestFit-PN,102.0,1213,0 +BestFit-PN,104.0,1213,0 +BestFit-PN,106.0,1213,0 +BestFit-PN,108.0,1213,0 +BestFit-PN,110.0,1213,0 +BestFit-PN,112.0,1213,0 +BestFit-PN,114.0,1213,0 +BestFit-PN,116.0,1213,0 +BestFit-PN,118.0,1213,0 +BestFit-PN,120.0,1213,0 +BestFit-PN,2.0,34,1 +BestFit-PN,4.0,54,1 +BestFit-PN,6.0,77,1 +BestFit-PN,8.0,99,1 +BestFit-PN,10.0,117,1 +BestFit-PN,12.0,153,1 +BestFit-PN,14.0,174,1 +BestFit-PN,16.0,195,1 +BestFit-PN,18.0,226,1 +BestFit-PN,20.0,253,1 +BestFit-PN,22.0,276,1 +BestFit-PN,24.0,301,1 +BestFit-PN,26.0,323,1 +BestFit-PN,28.0,342,1 +BestFit-PN,30.0,361,1 +BestFit-PN,32.0,385,1 +BestFit-PN,34.0,417,1 +BestFit-PN,36.0,445,1 +BestFit-PN,38.0,469,1 +BestFit-PN,40.0,494,1 +BestFit-PN,42.0,513,1 +BestFit-PN,44.0,533,1 +BestFit-PN,46.0,561,1 +BestFit-PN,48.0,585,1 +BestFit-PN,50.0,625,1 +BestFit-PN,52.0,661,1 +BestFit-PN,54.0,680,1 +BestFit-PN,56.0,713,1 +BestFit-PN,58.0,746,1 +BestFit-PN,60.0,778,1 +BestFit-PN,62.0,802,1 +BestFit-PN,64.0,819,1 +BestFit-PN,66.0,836,1 +BestFit-PN,68.0,856,1 +BestFit-PN,70.0,887,1 +BestFit-PN,72.0,909,1 +BestFit-PN,74.0,931,1 +BestFit-PN,76.0,960,1 +BestFit-PN,78.0,981,1 +BestFit-PN,80.0,1004,1 +BestFit-PN,82.0,1029,1 +BestFit-PN,84.0,1049,1 +BestFit-PN,86.0,1080,1 +BestFit-PN,88.0,1110,1 +BestFit-PN,90.0,1145,1 +BestFit-PN,92.0,1188,1 +BestFit-PN,94.0,1213,1 +BestFit-PN,96.0,1213,1 +BestFit-PN,98.0,1213,1 +BestFit-PN,100.0,1213,1 +BestFit-PN,102.0,1213,1 +BestFit-PN,104.0,1213,1 +BestFit-PN,106.0,1213,1 +BestFit-PN,108.0,1213,1 +BestFit-PN,110.0,1213,1 +BestFit-PN,112.0,1213,1 +BestFit-PN,114.0,1213,1 +BestFit-PN,116.0,1213,1 +BestFit-PN,118.0,1213,1 +BestFit-PN,120.0,1213,1 +BestFit-PN,2.0,35,2 +BestFit-PN,4.0,53,2 +BestFit-PN,6.0,76,2 +BestFit-PN,8.0,98,2 +BestFit-PN,10.0,117,2 +BestFit-PN,12.0,152,2 +BestFit-PN,14.0,173,2 +BestFit-PN,16.0,193,2 +BestFit-PN,18.0,224,2 +BestFit-PN,20.0,250,2 +BestFit-PN,22.0,273,2 +BestFit-PN,24.0,295,2 +BestFit-PN,26.0,321,2 +BestFit-PN,28.0,340,2 +BestFit-PN,30.0,358,2 +BestFit-PN,32.0,384,2 +BestFit-PN,34.0,410,2 +BestFit-PN,36.0,440,2 +BestFit-PN,38.0,466,2 +BestFit-PN,40.0,494,2 +BestFit-PN,42.0,513,2 +BestFit-PN,44.0,532,2 +BestFit-PN,46.0,560,2 +BestFit-PN,48.0,586,2 +BestFit-PN,50.0,624,2 +BestFit-PN,52.0,661,2 +BestFit-PN,54.0,682,2 +BestFit-PN,56.0,715,2 +BestFit-PN,58.0,748,2 +BestFit-PN,60.0,783,2 +BestFit-PN,62.0,804,2 +BestFit-PN,64.0,820,2 +BestFit-PN,66.0,837,2 +BestFit-PN,68.0,858,2 +BestFit-PN,70.0,890,2 +BestFit-PN,72.0,913,2 +BestFit-PN,74.0,935,2 +BestFit-PN,76.0,963,2 +BestFit-PN,78.0,984,2 +BestFit-PN,80.0,1009,2 +BestFit-PN,82.0,1035,2 +BestFit-PN,84.0,1061,2 +BestFit-PN,86.0,1086,2 +BestFit-PN,88.0,1115,2 +BestFit-PN,90.0,1148,2 +BestFit-PN,92.0,1190,2 +BestFit-PN,94.0,1213,2 +BestFit-PN,96.0,1213,2 +BestFit-PN,98.0,1213,2 +BestFit-PN,100.0,1213,2 +BestFit-PN,102.0,1213,2 +BestFit-PN,104.0,1213,2 +BestFit-PN,106.0,1213,2 +BestFit-PN,108.0,1213,2 +BestFit-PN,110.0,1213,2 +BestFit-PN,112.0,1213,2 +BestFit-PN,114.0,1213,2 +BestFit-PN,116.0,1213,2 +BestFit-PN,118.0,1213,2 +BestFit-PN,120.0,1213,2 +BestFit-PN,2.0,34,3 +BestFit-PN,4.0,53,3 +BestFit-PN,6.0,76,3 +BestFit-PN,8.0,97,3 +BestFit-PN,10.0,121,3 +BestFit-PN,12.0,154,3 +BestFit-PN,14.0,176,3 +BestFit-PN,16.0,197,3 +BestFit-PN,18.0,228,3 +BestFit-PN,20.0,257,3 +BestFit-PN,22.0,277,3 +BestFit-PN,24.0,302,3 +BestFit-PN,26.0,324,3 +BestFit-PN,28.0,342,3 +BestFit-PN,30.0,361,3 +BestFit-PN,32.0,386,3 +BestFit-PN,34.0,419,3 +BestFit-PN,36.0,445,3 +BestFit-PN,38.0,469,3 +BestFit-PN,40.0,496,3 +BestFit-PN,42.0,514,3 +BestFit-PN,44.0,536,3 +BestFit-PN,46.0,562,3 +BestFit-PN,48.0,587,3 +BestFit-PN,50.0,625,3 +BestFit-PN,52.0,662,3 +BestFit-PN,54.0,683,3 +BestFit-PN,56.0,719,3 +BestFit-PN,58.0,749,3 +BestFit-PN,60.0,784,3 +BestFit-PN,62.0,805,3 +BestFit-PN,64.0,822,3 +BestFit-PN,66.0,839,3 +BestFit-PN,68.0,859,3 +BestFit-PN,70.0,891,3 +BestFit-PN,72.0,913,3 +BestFit-PN,74.0,935,3 +BestFit-PN,76.0,963,3 +BestFit-PN,78.0,984,3 +BestFit-PN,80.0,1009,3 +BestFit-PN,82.0,1035,3 +BestFit-PN,84.0,1062,3 +BestFit-PN,86.0,1087,3 +BestFit-PN,88.0,1117,3 +BestFit-PN,90.0,1153,3 +BestFit-PN,92.0,1191,3 +BestFit-PN,94.0,1213,3 +BestFit-PN,96.0,1213,3 +BestFit-PN,98.0,1213,3 +BestFit-PN,100.0,1213,3 +BestFit-PN,102.0,1213,3 +BestFit-PN,104.0,1213,3 +BestFit-PN,106.0,1213,3 +BestFit-PN,108.0,1213,3 +BestFit-PN,110.0,1213,3 +BestFit-PN,112.0,1213,3 +BestFit-PN,114.0,1213,3 +BestFit-PN,116.0,1213,3 +BestFit-PN,118.0,1213,3 +BestFit-PN,120.0,1213,3 +BestFit-PN,2.0,34,4 +BestFit-PN,4.0,53,4 +BestFit-PN,6.0,76,4 +BestFit-PN,8.0,97,4 +BestFit-PN,10.0,116,4 +BestFit-PN,12.0,152,4 +BestFit-PN,14.0,173,4 +BestFit-PN,16.0,192,4 +BestFit-PN,18.0,223,4 +BestFit-PN,20.0,250,4 +BestFit-PN,22.0,275,4 +BestFit-PN,24.0,294,4 +BestFit-PN,26.0,322,4 +BestFit-PN,28.0,340,4 +BestFit-PN,30.0,359,4 +BestFit-PN,32.0,381,4 +BestFit-PN,34.0,409,4 +BestFit-PN,36.0,440,4 +BestFit-PN,38.0,466,4 +BestFit-PN,40.0,487,4 +BestFit-PN,42.0,511,4 +BestFit-PN,44.0,529,4 +BestFit-PN,46.0,557,4 +BestFit-PN,48.0,581,4 +BestFit-PN,50.0,621,4 +BestFit-PN,52.0,658,4 +BestFit-PN,54.0,677,4 +BestFit-PN,56.0,710,4 +BestFit-PN,58.0,744,4 +BestFit-PN,60.0,773,4 +BestFit-PN,62.0,798,4 +BestFit-PN,64.0,816,4 +BestFit-PN,66.0,833,4 +BestFit-PN,68.0,854,4 +BestFit-PN,70.0,884,4 +BestFit-PN,72.0,906,4 +BestFit-PN,74.0,928,4 +BestFit-PN,76.0,958,4 +BestFit-PN,78.0,978,4 +BestFit-PN,80.0,1002,4 +BestFit-PN,82.0,1026,4 +BestFit-PN,84.0,1048,4 +BestFit-PN,86.0,1078,4 +BestFit-PN,88.0,1108,4 +BestFit-PN,90.0,1140,4 +BestFit-PN,92.0,1180,4 +BestFit-PN,94.0,1213,4 +BestFit-PN,96.0,1213,4 +BestFit-PN,98.0,1213,4 +BestFit-PN,100.0,1213,4 +BestFit-PN,102.0,1213,4 +BestFit-PN,104.0,1213,4 +BestFit-PN,106.0,1213,4 +BestFit-PN,108.0,1213,4 +BestFit-PN,110.0,1213,4 +BestFit-PN,112.0,1213,4 +BestFit-PN,114.0,1213,4 +BestFit-PN,116.0,1213,4 +BestFit-PN,118.0,1213,4 +BestFit-PN,120.0,1213,4 +BestFit-PN,2.0,34,5 +BestFit-PN,4.0,53,5 +BestFit-PN,6.0,76,5 +BestFit-PN,8.0,96,5 +BestFit-PN,10.0,117,5 +BestFit-PN,12.0,152,5 +BestFit-PN,14.0,173,5 +BestFit-PN,16.0,195,5 +BestFit-PN,18.0,226,5 +BestFit-PN,20.0,253,5 +BestFit-PN,22.0,276,5 +BestFit-PN,24.0,301,5 +BestFit-PN,26.0,324,5 +BestFit-PN,28.0,341,5 +BestFit-PN,30.0,361,5 +BestFit-PN,32.0,385,5 +BestFit-PN,34.0,414,5 +BestFit-PN,36.0,444,5 +BestFit-PN,38.0,468,5 +BestFit-PN,40.0,493,5 +BestFit-PN,42.0,514,5 +BestFit-PN,44.0,533,5 +BestFit-PN,46.0,561,5 +BestFit-PN,48.0,587,5 +BestFit-PN,50.0,624,5 +BestFit-PN,52.0,661,5 +BestFit-PN,54.0,681,5 +BestFit-PN,56.0,713,5 +BestFit-PN,58.0,747,5 +BestFit-PN,60.0,781,5 +BestFit-PN,62.0,803,5 +BestFit-PN,64.0,820,5 +BestFit-PN,66.0,838,5 +BestFit-PN,68.0,857,5 +BestFit-PN,70.0,889,5 +BestFit-PN,72.0,911,5 +BestFit-PN,74.0,934,5 +BestFit-PN,76.0,961,5 +BestFit-PN,78.0,983,5 +BestFit-PN,80.0,1006,5 +BestFit-PN,82.0,1031,5 +BestFit-PN,84.0,1051,5 +BestFit-PN,86.0,1085,5 +BestFit-PN,88.0,1112,5 +BestFit-PN,90.0,1150,5 +BestFit-PN,92.0,1189,5 +BestFit-PN,94.0,1213,5 +BestFit-PN,96.0,1213,5 +BestFit-PN,98.0,1213,5 +BestFit-PN,100.0,1213,5 +BestFit-PN,102.0,1213,5 +BestFit-PN,104.0,1213,5 +BestFit-PN,106.0,1213,5 +BestFit-PN,108.0,1213,5 +BestFit-PN,110.0,1213,5 +BestFit-PN,112.0,1213,5 +BestFit-PN,114.0,1213,5 +BestFit-PN,116.0,1213,5 +BestFit-PN,118.0,1213,5 +BestFit-PN,120.0,1213,5 +BestFit-PN,2.0,34,6 +BestFit-PN,4.0,53,6 +BestFit-PN,6.0,76,6 +BestFit-PN,8.0,96,6 +BestFit-PN,10.0,117,6 +BestFit-PN,12.0,152,6 +BestFit-PN,14.0,173,6 +BestFit-PN,16.0,192,6 +BestFit-PN,18.0,224,6 +BestFit-PN,20.0,250,6 +BestFit-PN,22.0,274,6 +BestFit-PN,24.0,297,6 +BestFit-PN,26.0,322,6 +BestFit-PN,28.0,339,6 +BestFit-PN,30.0,358,6 +BestFit-PN,32.0,383,6 +BestFit-PN,34.0,411,6 +BestFit-PN,36.0,442,6 +BestFit-PN,38.0,467,6 +BestFit-PN,40.0,488,6 +BestFit-PN,42.0,512,6 +BestFit-PN,44.0,529,6 +BestFit-PN,46.0,558,6 +BestFit-PN,48.0,583,6 +BestFit-PN,50.0,622,6 +BestFit-PN,52.0,659,6 +BestFit-PN,54.0,678,6 +BestFit-PN,56.0,710,6 +BestFit-PN,58.0,745,6 +BestFit-PN,60.0,774,6 +BestFit-PN,62.0,799,6 +BestFit-PN,64.0,817,6 +BestFit-PN,66.0,835,6 +BestFit-PN,68.0,855,6 +BestFit-PN,70.0,882,6 +BestFit-PN,72.0,907,6 +BestFit-PN,74.0,928,6 +BestFit-PN,76.0,959,6 +BestFit-PN,78.0,979,6 +BestFit-PN,80.0,1002,6 +BestFit-PN,82.0,1026,6 +BestFit-PN,84.0,1046,6 +BestFit-PN,86.0,1078,6 +BestFit-PN,88.0,1108,6 +BestFit-PN,90.0,1140,6 +BestFit-PN,92.0,1183,6 +BestFit-PN,94.0,1213,6 +BestFit-PN,96.0,1213,6 +BestFit-PN,98.0,1213,6 +BestFit-PN,100.0,1213,6 +BestFit-PN,102.0,1213,6 +BestFit-PN,104.0,1213,6 +BestFit-PN,106.0,1213,6 +BestFit-PN,108.0,1213,6 +BestFit-PN,110.0,1213,6 +BestFit-PN,112.0,1213,6 +BestFit-PN,114.0,1213,6 +BestFit-PN,116.0,1213,6 +BestFit-PN,118.0,1213,6 +BestFit-PN,120.0,1213,6 +BestFit-PN,2.0,34,7 +BestFit-PN,4.0,53,7 +BestFit-PN,6.0,76,7 +BestFit-PN,8.0,96,7 +BestFit-PN,10.0,116,7 +BestFit-PN,12.0,152,7 +BestFit-PN,14.0,173,7 +BestFit-PN,16.0,192,7 +BestFit-PN,18.0,224,7 +BestFit-PN,20.0,251,7 +BestFit-PN,22.0,274,7 +BestFit-PN,24.0,296,7 +BestFit-PN,26.0,322,7 +BestFit-PN,28.0,340,7 +BestFit-PN,30.0,360,7 +BestFit-PN,32.0,384,7 +BestFit-PN,34.0,412,7 +BestFit-PN,36.0,443,7 +BestFit-PN,38.0,468,7 +BestFit-PN,40.0,492,7 +BestFit-PN,42.0,513,7 +BestFit-PN,44.0,533,7 +BestFit-PN,46.0,561,7 +BestFit-PN,48.0,585,7 +BestFit-PN,50.0,624,7 +BestFit-PN,52.0,661,7 +BestFit-PN,54.0,681,7 +BestFit-PN,56.0,713,7 +BestFit-PN,58.0,747,7 +BestFit-PN,60.0,777,7 +BestFit-PN,62.0,803,7 +BestFit-PN,64.0,819,7 +BestFit-PN,66.0,838,7 +BestFit-PN,68.0,858,7 +BestFit-PN,70.0,890,7 +BestFit-PN,72.0,912,7 +BestFit-PN,74.0,935,7 +BestFit-PN,76.0,963,7 +BestFit-PN,78.0,984,7 +BestFit-PN,80.0,1009,7 +BestFit-PN,82.0,1035,7 +BestFit-PN,84.0,1062,7 +BestFit-PN,86.0,1086,7 +BestFit-PN,88.0,1116,7 +BestFit-PN,90.0,1153,7 +BestFit-PN,92.0,1192,7 +BestFit-PN,94.0,1213,7 +BestFit-PN,96.0,1213,7 +BestFit-PN,98.0,1213,7 +BestFit-PN,100.0,1213,7 +BestFit-PN,102.0,1213,7 +BestFit-PN,104.0,1213,7 +BestFit-PN,106.0,1213,7 +BestFit-PN,108.0,1213,7 +BestFit-PN,110.0,1213,7 +BestFit-PN,112.0,1213,7 +BestFit-PN,114.0,1213,7 +BestFit-PN,116.0,1213,7 +BestFit-PN,118.0,1213,7 +BestFit-PN,120.0,1213,7 +BestFit-PN,2.0,34,8 +BestFit-PN,4.0,53,8 +BestFit-PN,6.0,76,8 +BestFit-PN,8.0,97,8 +BestFit-PN,10.0,117,8 +BestFit-PN,12.0,153,8 +BestFit-PN,14.0,174,8 +BestFit-PN,16.0,194,8 +BestFit-PN,18.0,224,8 +BestFit-PN,20.0,251,8 +BestFit-PN,22.0,275,8 +BestFit-PN,24.0,294,8 +BestFit-PN,26.0,322,8 +BestFit-PN,28.0,340,8 +BestFit-PN,30.0,358,8 +BestFit-PN,32.0,384,8 +BestFit-PN,34.0,409,8 +BestFit-PN,36.0,441,8 +BestFit-PN,38.0,467,8 +BestFit-PN,40.0,490,8 +BestFit-PN,42.0,512,8 +BestFit-PN,44.0,531,8 +BestFit-PN,46.0,559,8 +BestFit-PN,48.0,584,8 +BestFit-PN,50.0,623,8 +BestFit-PN,52.0,659,8 +BestFit-PN,54.0,678,8 +BestFit-PN,56.0,710,8 +BestFit-PN,58.0,744,8 +BestFit-PN,60.0,774,8 +BestFit-PN,62.0,800,8 +BestFit-PN,64.0,817,8 +BestFit-PN,66.0,835,8 +BestFit-PN,68.0,855,8 +BestFit-PN,70.0,886,8 +BestFit-PN,72.0,909,8 +BestFit-PN,74.0,929,8 +BestFit-PN,76.0,960,8 +BestFit-PN,78.0,981,8 +BestFit-PN,80.0,1005,8 +BestFit-PN,82.0,1030,8 +BestFit-PN,84.0,1049,8 +BestFit-PN,86.0,1080,8 +BestFit-PN,88.0,1109,8 +BestFit-PN,90.0,1141,8 +BestFit-PN,92.0,1186,8 +BestFit-PN,94.0,1213,8 +BestFit-PN,96.0,1213,8 +BestFit-PN,98.0,1213,8 +BestFit-PN,100.0,1213,8 +BestFit-PN,102.0,1213,8 +BestFit-PN,104.0,1213,8 +BestFit-PN,106.0,1213,8 +BestFit-PN,108.0,1213,8 +BestFit-PN,110.0,1213,8 +BestFit-PN,112.0,1213,8 +BestFit-PN,114.0,1213,8 +BestFit-PN,116.0,1213,8 +BestFit-PN,118.0,1213,8 +BestFit-PN,120.0,1213,8 +BestFit-PN,2.0,35,9 +BestFit-PN,4.0,53,9 +BestFit-PN,6.0,77,9 +BestFit-PN,8.0,97,9 +BestFit-PN,10.0,117,9 +BestFit-PN,12.0,151,9 +BestFit-PN,14.0,173,9 +BestFit-PN,16.0,192,9 +BestFit-PN,18.0,224,9 +BestFit-PN,20.0,250,9 +BestFit-PN,22.0,274,9 +BestFit-PN,24.0,295,9 +BestFit-PN,26.0,321,9 +BestFit-PN,28.0,339,9 +BestFit-PN,30.0,359,9 +BestFit-PN,32.0,382,9 +BestFit-PN,34.0,409,9 +BestFit-PN,36.0,442,9 +BestFit-PN,38.0,467,9 +BestFit-PN,40.0,492,9 +BestFit-PN,42.0,511,9 +BestFit-PN,44.0,532,9 +BestFit-PN,46.0,560,9 +BestFit-PN,48.0,585,9 +BestFit-PN,50.0,624,9 +BestFit-PN,52.0,660,9 +BestFit-PN,54.0,680,9 +BestFit-PN,56.0,713,9 +BestFit-PN,58.0,747,9 +BestFit-PN,60.0,780,9 +BestFit-PN,62.0,803,9 +BestFit-PN,64.0,819,9 +BestFit-PN,66.0,838,9 +BestFit-PN,68.0,857,9 +BestFit-PN,70.0,888,9 +BestFit-PN,72.0,912,9 +BestFit-PN,74.0,935,9 +BestFit-PN,76.0,962,9 +BestFit-PN,78.0,983,9 +BestFit-PN,80.0,1007,9 +BestFit-PN,82.0,1032,9 +BestFit-PN,84.0,1054,9 +BestFit-PN,86.0,1085,9 +BestFit-PN,88.0,1112,9 +BestFit-PN,90.0,1149,9 +BestFit-PN,92.0,1188,9 +BestFit-PN,94.0,1213,9 +BestFit-PN,96.0,1213,9 +BestFit-PN,98.0,1213,9 +BestFit-PN,100.0,1213,9 +BestFit-PN,102.0,1213,9 +BestFit-PN,104.0,1213,9 +BestFit-PN,106.0,1213,9 +BestFit-PN,108.0,1213,9 +BestFit-PN,110.0,1213,9 +BestFit-PN,112.0,1213,9 +BestFit-PN,114.0,1213,9 +BestFit-PN,116.0,1213,9 +BestFit-PN,118.0,1213,9 +BestFit-PN,120.0,1213,9 +DotProd,2.0,114,0 +DotProd,4.0,185,0 +DotProd,6.0,242,0 +DotProd,8.0,309,0 +DotProd,10.0,379,0 +DotProd,12.0,444,0 +DotProd,14.0,506,0 +DotProd,16.0,562,0 +DotProd,18.0,607,0 +DotProd,20.0,624,0 +DotProd,22.0,641,0 +DotProd,24.0,657,0 +DotProd,26.0,674,0 +DotProd,28.0,691,0 +DotProd,30.0,708,0 +DotProd,32.0,724,0 +DotProd,34.0,741,0 +DotProd,36.0,758,0 +DotProd,38.0,775,0 +DotProd,40.0,792,0 +DotProd,42.0,809,0 +DotProd,44.0,826,0 +DotProd,46.0,844,0 +DotProd,48.0,861,0 +DotProd,50.0,878,0 +DotProd,52.0,896,0 +DotProd,54.0,912,0 +DotProd,56.0,929,0 +DotProd,58.0,945,0 +DotProd,60.0,963,0 +DotProd,62.0,979,0 +DotProd,64.0,996,0 +DotProd,66.0,1013,0 +DotProd,68.0,1030,0 +DotProd,70.0,1047,0 +DotProd,72.0,1064,0 +DotProd,74.0,1081,0 +DotProd,76.0,1098,0 +DotProd,78.0,1115,0 +DotProd,80.0,1134,0 +DotProd,82.0,1151,0 +DotProd,84.0,1168,0 +DotProd,86.0,1184,0 +DotProd,88.0,1200,0 +DotProd,90.0,1213,0 +DotProd,92.0,1213,0 +DotProd,94.0,1213,0 +DotProd,96.0,1213,0 +DotProd,98.0,1213,0 +DotProd,100.0,1213,0 +DotProd,102.0,1213,0 +DotProd,104.0,1213,0 +DotProd,106.0,1213,0 +DotProd,108.0,1213,0 +DotProd,110.0,1213,0 +DotProd,112.0,1213,0 +DotProd,114.0,1213,0 +DotProd,116.0,1213,0 +DotProd,118.0,1213,0 +DotProd,120.0,1213,0 +DotProd,2.0,121,1 +DotProd,4.0,185,1 +DotProd,6.0,246,1 +DotProd,8.0,307,1 +DotProd,10.0,372,1 +DotProd,12.0,432,1 +DotProd,14.0,493,1 +DotProd,16.0,557,1 +DotProd,18.0,607,1 +DotProd,20.0,624,1 +DotProd,22.0,641,1 +DotProd,24.0,658,1 +DotProd,26.0,675,1 +DotProd,28.0,693,1 +DotProd,30.0,709,1 +DotProd,32.0,726,1 +DotProd,34.0,742,1 +DotProd,36.0,759,1 +DotProd,38.0,776,1 +DotProd,40.0,792,1 +DotProd,42.0,809,1 +DotProd,44.0,827,1 +DotProd,46.0,844,1 +DotProd,48.0,860,1 +DotProd,50.0,878,1 +DotProd,52.0,895,1 +DotProd,54.0,911,1 +DotProd,56.0,928,1 +DotProd,58.0,945,1 +DotProd,60.0,962,1 +DotProd,62.0,979,1 +DotProd,64.0,996,1 +DotProd,66.0,1014,1 +DotProd,68.0,1030,1 +DotProd,70.0,1048,1 +DotProd,72.0,1064,1 +DotProd,74.0,1081,1 +DotProd,76.0,1098,1 +DotProd,78.0,1115,1 +DotProd,80.0,1132,1 +DotProd,82.0,1148,1 +DotProd,84.0,1166,1 +DotProd,86.0,1183,1 +DotProd,88.0,1199,1 +DotProd,90.0,1213,1 +DotProd,92.0,1213,1 +DotProd,94.0,1213,1 +DotProd,96.0,1213,1 +DotProd,98.0,1213,1 +DotProd,100.0,1213,1 +DotProd,102.0,1213,1 +DotProd,104.0,1213,1 +DotProd,106.0,1213,1 +DotProd,108.0,1213,1 +DotProd,110.0,1213,1 +DotProd,112.0,1213,1 +DotProd,114.0,1213,1 +DotProd,116.0,1213,1 +DotProd,118.0,1213,1 +DotProd,120.0,1213,1 +DotProd,2.0,116,2 +DotProd,4.0,181,2 +DotProd,6.0,231,2 +DotProd,8.0,298,2 +DotProd,10.0,361,2 +DotProd,12.0,427,2 +DotProd,14.0,490,2 +DotProd,16.0,544,2 +DotProd,18.0,602,2 +DotProd,20.0,624,2 +DotProd,22.0,640,2 +DotProd,24.0,657,2 +DotProd,26.0,674,2 +DotProd,28.0,691,2 +DotProd,30.0,708,2 +DotProd,32.0,725,2 +DotProd,34.0,741,2 +DotProd,36.0,757,2 +DotProd,38.0,773,2 +DotProd,40.0,791,2 +DotProd,42.0,808,2 +DotProd,44.0,826,2 +DotProd,46.0,843,2 +DotProd,48.0,860,2 +DotProd,50.0,877,2 +DotProd,52.0,895,2 +DotProd,54.0,913,2 +DotProd,56.0,930,2 +DotProd,58.0,946,2 +DotProd,60.0,964,2 +DotProd,62.0,981,2 +DotProd,64.0,999,2 +DotProd,66.0,1016,2 +DotProd,68.0,1033,2 +DotProd,70.0,1050,2 +DotProd,72.0,1067,2 +DotProd,74.0,1085,2 +DotProd,76.0,1102,2 +DotProd,78.0,1119,2 +DotProd,80.0,1137,2 +DotProd,82.0,1154,2 +DotProd,84.0,1171,2 +DotProd,86.0,1187,2 +DotProd,88.0,1203,2 +DotProd,90.0,1213,2 +DotProd,92.0,1213,2 +DotProd,94.0,1213,2 +DotProd,96.0,1213,2 +DotProd,98.0,1213,2 +DotProd,100.0,1213,2 +DotProd,102.0,1213,2 +DotProd,104.0,1213,2 +DotProd,106.0,1213,2 +DotProd,108.0,1213,2 +DotProd,110.0,1213,2 +DotProd,112.0,1213,2 +DotProd,114.0,1213,2 +DotProd,116.0,1213,2 +DotProd,118.0,1213,2 +DotProd,120.0,1213,2 +DotProd,2.0,112,3 +DotProd,4.0,187,3 +DotProd,6.0,241,3 +DotProd,8.0,313,3 +DotProd,10.0,376,3 +DotProd,12.0,438,3 +DotProd,14.0,503,3 +DotProd,16.0,570,3 +DotProd,18.0,610,3 +DotProd,20.0,627,3 +DotProd,22.0,643,3 +DotProd,24.0,660,3 +DotProd,26.0,678,3 +DotProd,28.0,695,3 +DotProd,30.0,711,3 +DotProd,32.0,727,3 +DotProd,34.0,744,3 +DotProd,36.0,762,3 +DotProd,38.0,780,3 +DotProd,40.0,796,3 +DotProd,42.0,813,3 +DotProd,44.0,829,3 +DotProd,46.0,846,3 +DotProd,48.0,863,3 +DotProd,50.0,880,3 +DotProd,52.0,896,3 +DotProd,54.0,913,3 +DotProd,56.0,930,3 +DotProd,58.0,947,3 +DotProd,60.0,964,3 +DotProd,62.0,981,3 +DotProd,64.0,998,3 +DotProd,66.0,1015,3 +DotProd,68.0,1031,3 +DotProd,70.0,1048,3 +DotProd,72.0,1065,3 +DotProd,74.0,1082,3 +DotProd,76.0,1099,3 +DotProd,78.0,1116,3 +DotProd,80.0,1133,3 +DotProd,82.0,1151,3 +DotProd,84.0,1168,3 +DotProd,86.0,1185,3 +DotProd,88.0,1201,3 +DotProd,90.0,1213,3 +DotProd,92.0,1213,3 +DotProd,94.0,1213,3 +DotProd,96.0,1213,3 +DotProd,98.0,1213,3 +DotProd,100.0,1213,3 +DotProd,102.0,1213,3 +DotProd,104.0,1213,3 +DotProd,106.0,1213,3 +DotProd,108.0,1213,3 +DotProd,110.0,1213,3 +DotProd,112.0,1213,3 +DotProd,114.0,1213,3 +DotProd,116.0,1213,3 +DotProd,118.0,1213,3 +DotProd,120.0,1213,3 +DotProd,2.0,118,4 +DotProd,4.0,186,4 +DotProd,6.0,234,4 +DotProd,8.0,296,4 +DotProd,10.0,361,4 +DotProd,12.0,424,4 +DotProd,14.0,484,4 +DotProd,16.0,546,4 +DotProd,18.0,604,4 +DotProd,20.0,626,4 +DotProd,22.0,642,4 +DotProd,24.0,659,4 +DotProd,26.0,676,4 +DotProd,28.0,692,4 +DotProd,30.0,709,4 +DotProd,32.0,726,4 +DotProd,34.0,743,4 +DotProd,36.0,760,4 +DotProd,38.0,777,4 +DotProd,40.0,795,4 +DotProd,42.0,812,4 +DotProd,44.0,829,4 +DotProd,46.0,846,4 +DotProd,48.0,863,4 +DotProd,50.0,879,4 +DotProd,52.0,896,4 +DotProd,54.0,913,4 +DotProd,56.0,930,4 +DotProd,58.0,948,4 +DotProd,60.0,964,4 +DotProd,62.0,981,4 +DotProd,64.0,998,4 +DotProd,66.0,1015,4 +DotProd,68.0,1031,4 +DotProd,70.0,1048,4 +DotProd,72.0,1065,4 +DotProd,74.0,1083,4 +DotProd,76.0,1099,4 +DotProd,78.0,1116,4 +DotProd,80.0,1132,4 +DotProd,82.0,1149,4 +DotProd,84.0,1166,4 +DotProd,86.0,1182,4 +DotProd,88.0,1199,4 +DotProd,90.0,1213,4 +DotProd,92.0,1213,4 +DotProd,94.0,1213,4 +DotProd,96.0,1213,4 +DotProd,98.0,1213,4 +DotProd,100.0,1213,4 +DotProd,102.0,1213,4 +DotProd,104.0,1213,4 +DotProd,106.0,1213,4 +DotProd,108.0,1213,4 +DotProd,110.0,1213,4 +DotProd,112.0,1213,4 +DotProd,114.0,1213,4 +DotProd,116.0,1213,4 +DotProd,118.0,1213,4 +DotProd,120.0,1213,4 +DotProd,2.0,120,5 +DotProd,4.0,185,5 +DotProd,6.0,236,5 +DotProd,8.0,299,5 +DotProd,10.0,363,5 +DotProd,12.0,424,5 +DotProd,14.0,488,5 +DotProd,16.0,551,5 +DotProd,18.0,604,5 +DotProd,20.0,623,5 +DotProd,22.0,640,5 +DotProd,24.0,657,5 +DotProd,26.0,673,5 +DotProd,28.0,690,5 +DotProd,30.0,707,5 +DotProd,32.0,724,5 +DotProd,34.0,740,5 +DotProd,36.0,759,5 +DotProd,38.0,775,5 +DotProd,40.0,792,5 +DotProd,42.0,810,5 +DotProd,44.0,827,5 +DotProd,46.0,843,5 +DotProd,48.0,860,5 +DotProd,50.0,877,5 +DotProd,52.0,893,5 +DotProd,54.0,911,5 +DotProd,56.0,928,5 +DotProd,58.0,944,5 +DotProd,60.0,961,5 +DotProd,62.0,978,5 +DotProd,64.0,995,5 +DotProd,66.0,1012,5 +DotProd,68.0,1029,5 +DotProd,70.0,1046,5 +DotProd,72.0,1063,5 +DotProd,74.0,1082,5 +DotProd,76.0,1099,5 +DotProd,78.0,1118,5 +DotProd,80.0,1134,5 +DotProd,82.0,1151,5 +DotProd,84.0,1168,5 +DotProd,86.0,1186,5 +DotProd,88.0,1202,5 +DotProd,90.0,1213,5 +DotProd,92.0,1213,5 +DotProd,94.0,1213,5 +DotProd,96.0,1213,5 +DotProd,98.0,1213,5 +DotProd,100.0,1213,5 +DotProd,102.0,1213,5 +DotProd,104.0,1213,5 +DotProd,106.0,1213,5 +DotProd,108.0,1213,5 +DotProd,110.0,1213,5 +DotProd,112.0,1213,5 +DotProd,114.0,1213,5 +DotProd,116.0,1213,5 +DotProd,118.0,1213,5 +DotProd,120.0,1213,5 +DotProd,2.0,118,6 +DotProd,4.0,187,6 +DotProd,6.0,243,6 +DotProd,8.0,299,6 +DotProd,10.0,362,6 +DotProd,12.0,425,6 +DotProd,14.0,492,6 +DotProd,16.0,553,6 +DotProd,18.0,604,6 +DotProd,20.0,625,6 +DotProd,22.0,643,6 +DotProd,24.0,659,6 +DotProd,26.0,676,6 +DotProd,28.0,693,6 +DotProd,30.0,709,6 +DotProd,32.0,726,6 +DotProd,34.0,745,6 +DotProd,36.0,761,6 +DotProd,38.0,777,6 +DotProd,40.0,794,6 +DotProd,42.0,811,6 +DotProd,44.0,827,6 +DotProd,46.0,844,6 +DotProd,48.0,862,6 +DotProd,50.0,880,6 +DotProd,52.0,897,6 +DotProd,54.0,913,6 +DotProd,56.0,931,6 +DotProd,58.0,948,6 +DotProd,60.0,964,6 +DotProd,62.0,981,6 +DotProd,64.0,998,6 +DotProd,66.0,1016,6 +DotProd,68.0,1031,6 +DotProd,70.0,1048,6 +DotProd,72.0,1064,6 +DotProd,74.0,1082,6 +DotProd,76.0,1099,6 +DotProd,78.0,1115,6 +DotProd,80.0,1132,6 +DotProd,82.0,1148,6 +DotProd,84.0,1165,6 +DotProd,86.0,1182,6 +DotProd,88.0,1198,6 +DotProd,90.0,1213,6 +DotProd,92.0,1213,6 +DotProd,94.0,1213,6 +DotProd,96.0,1213,6 +DotProd,98.0,1213,6 +DotProd,100.0,1213,6 +DotProd,102.0,1213,6 +DotProd,104.0,1213,6 +DotProd,106.0,1213,6 +DotProd,108.0,1213,6 +DotProd,110.0,1213,6 +DotProd,112.0,1213,6 +DotProd,114.0,1213,6 +DotProd,116.0,1213,6 +DotProd,118.0,1213,6 +DotProd,120.0,1213,6 +DotProd,2.0,113,7 +DotProd,4.0,183,7 +DotProd,6.0,229,7 +DotProd,8.0,295,7 +DotProd,10.0,363,7 +DotProd,12.0,424,7 +DotProd,14.0,490,7 +DotProd,16.0,554,7 +DotProd,18.0,605,7 +DotProd,20.0,624,7 +DotProd,22.0,641,7 +DotProd,24.0,657,7 +DotProd,26.0,674,7 +DotProd,28.0,692,7 +DotProd,30.0,709,7 +DotProd,32.0,725,7 +DotProd,34.0,742,7 +DotProd,36.0,759,7 +DotProd,38.0,776,7 +DotProd,40.0,793,7 +DotProd,42.0,811,7 +DotProd,44.0,828,7 +DotProd,46.0,845,7 +DotProd,48.0,862,7 +DotProd,50.0,878,7 +DotProd,52.0,896,7 +DotProd,54.0,913,7 +DotProd,56.0,930,7 +DotProd,58.0,947,7 +DotProd,60.0,964,7 +DotProd,62.0,982,7 +DotProd,64.0,998,7 +DotProd,66.0,1015,7 +DotProd,68.0,1032,7 +DotProd,70.0,1049,7 +DotProd,72.0,1066,7 +DotProd,74.0,1083,7 +DotProd,76.0,1100,7 +DotProd,78.0,1117,7 +DotProd,80.0,1134,7 +DotProd,82.0,1151,7 +DotProd,84.0,1169,7 +DotProd,86.0,1185,7 +DotProd,88.0,1202,7 +DotProd,90.0,1213,7 +DotProd,92.0,1213,7 +DotProd,94.0,1213,7 +DotProd,96.0,1213,7 +DotProd,98.0,1213,7 +DotProd,100.0,1213,7 +DotProd,102.0,1213,7 +DotProd,104.0,1213,7 +DotProd,106.0,1213,7 +DotProd,108.0,1213,7 +DotProd,110.0,1213,7 +DotProd,112.0,1213,7 +DotProd,114.0,1213,7 +DotProd,116.0,1213,7 +DotProd,118.0,1213,7 +DotProd,120.0,1213,7 +DotProd,2.0,115,8 +DotProd,4.0,185,8 +DotProd,6.0,243,8 +DotProd,8.0,308,8 +DotProd,10.0,372,8 +DotProd,12.0,434,8 +DotProd,14.0,494,8 +DotProd,16.0,553,8 +DotProd,18.0,606,8 +DotProd,20.0,625,8 +DotProd,22.0,642,8 +DotProd,24.0,659,8 +DotProd,26.0,675,8 +DotProd,28.0,694,8 +DotProd,30.0,710,8 +DotProd,32.0,727,8 +DotProd,34.0,744,8 +DotProd,36.0,761,8 +DotProd,38.0,778,8 +DotProd,40.0,795,8 +DotProd,42.0,811,8 +DotProd,44.0,827,8 +DotProd,46.0,845,8 +DotProd,48.0,862,8 +DotProd,50.0,880,8 +DotProd,52.0,896,8 +DotProd,54.0,912,8 +DotProd,56.0,929,8 +DotProd,58.0,946,8 +DotProd,60.0,963,8 +DotProd,62.0,981,8 +DotProd,64.0,998,8 +DotProd,66.0,1014,8 +DotProd,68.0,1031,8 +DotProd,70.0,1048,8 +DotProd,72.0,1064,8 +DotProd,74.0,1082,8 +DotProd,76.0,1099,8 +DotProd,78.0,1116,8 +DotProd,80.0,1132,8 +DotProd,82.0,1149,8 +DotProd,84.0,1165,8 +DotProd,86.0,1182,8 +DotProd,88.0,1198,8 +DotProd,90.0,1213,8 +DotProd,92.0,1213,8 +DotProd,94.0,1213,8 +DotProd,96.0,1213,8 +DotProd,98.0,1213,8 +DotProd,100.0,1213,8 +DotProd,102.0,1213,8 +DotProd,104.0,1213,8 +DotProd,106.0,1213,8 +DotProd,108.0,1213,8 +DotProd,110.0,1213,8 +DotProd,112.0,1213,8 +DotProd,114.0,1213,8 +DotProd,116.0,1213,8 +DotProd,118.0,1213,8 +DotProd,120.0,1213,8 +DotProd,2.0,121,9 +DotProd,4.0,188,9 +DotProd,6.0,240,9 +DotProd,8.0,297,9 +DotProd,10.0,359,9 +DotProd,12.0,421,9 +DotProd,14.0,480,9 +DotProd,16.0,544,9 +DotProd,18.0,604,9 +DotProd,20.0,625,9 +DotProd,22.0,642,9 +DotProd,24.0,658,9 +DotProd,26.0,674,9 +DotProd,28.0,691,9 +DotProd,30.0,708,9 +DotProd,32.0,725,9 +DotProd,34.0,742,9 +DotProd,36.0,759,9 +DotProd,38.0,777,9 +DotProd,40.0,794,9 +DotProd,42.0,812,9 +DotProd,44.0,830,9 +DotProd,46.0,847,9 +DotProd,48.0,864,9 +DotProd,50.0,881,9 +DotProd,52.0,898,9 +DotProd,54.0,915,9 +DotProd,56.0,932,9 +DotProd,58.0,949,9 +DotProd,60.0,966,9 +DotProd,62.0,983,9 +DotProd,64.0,1001,9 +DotProd,66.0,1017,9 +DotProd,68.0,1034,9 +DotProd,70.0,1051,9 +DotProd,72.0,1068,9 +DotProd,74.0,1085,9 +DotProd,76.0,1103,9 +DotProd,78.0,1120,9 +DotProd,80.0,1136,9 +DotProd,82.0,1153,9 +DotProd,84.0,1170,9 +DotProd,86.0,1187,9 +DotProd,88.0,1203,9 +DotProd,90.0,1213,9 +DotProd,92.0,1213,9 +DotProd,94.0,1213,9 +DotProd,96.0,1213,9 +DotProd,98.0,1213,9 +DotProd,100.0,1213,9 +DotProd,102.0,1213,9 +DotProd,104.0,1213,9 +DotProd,106.0,1213,9 +DotProd,108.0,1213,9 +DotProd,110.0,1213,9 +DotProd,112.0,1213,9 +DotProd,114.0,1213,9 +DotProd,116.0,1213,9 +DotProd,118.0,1213,9 +DotProd,120.0,1213,9 +Packing,2.0,81,0 +Packing,4.0,148,0 +Packing,6.0,211,0 +Packing,8.0,279,0 +Packing,10.0,346,0 +Packing,12.0,412,0 +Packing,14.0,478,0 +Packing,16.0,534,0 +Packing,18.0,574,0 +Packing,20.0,606,0 +Packing,22.0,622,0 +Packing,24.0,639,0 +Packing,26.0,655,0 +Packing,28.0,671,0 +Packing,30.0,688,0 +Packing,32.0,704,0 +Packing,34.0,720,0 +Packing,36.0,737,0 +Packing,38.0,754,0 +Packing,40.0,770,0 +Packing,42.0,786,0 +Packing,44.0,803,0 +Packing,46.0,819,0 +Packing,48.0,836,0 +Packing,50.0,852,0 +Packing,52.0,869,0 +Packing,54.0,885,0 +Packing,56.0,901,0 +Packing,58.0,917,0 +Packing,60.0,934,0 +Packing,62.0,950,0 +Packing,64.0,966,0 +Packing,66.0,983,0 +Packing,68.0,999,0 +Packing,70.0,1016,0 +Packing,72.0,1032,0 +Packing,74.0,1049,0 +Packing,76.0,1065,0 +Packing,78.0,1082,0 +Packing,80.0,1098,0 +Packing,82.0,1114,0 +Packing,84.0,1131,0 +Packing,86.0,1147,0 +Packing,88.0,1163,0 +Packing,90.0,1180,0 +Packing,92.0,1196,0 +Packing,94.0,1212,0 +Packing,96.0,1213,0 +Packing,98.0,1213,0 +Packing,100.0,1213,0 +Packing,102.0,1213,0 +Packing,104.0,1213,0 +Packing,106.0,1213,0 +Packing,108.0,1213,0 +Packing,110.0,1213,0 +Packing,112.0,1213,0 +Packing,114.0,1213,0 +Packing,116.0,1213,0 +Packing,118.0,1213,0 +Packing,120.0,1213,0 +Packing,2.0,78,1 +Packing,4.0,142,1 +Packing,6.0,208,1 +Packing,8.0,272,1 +Packing,10.0,333,1 +Packing,12.0,393,1 +Packing,14.0,459,1 +Packing,16.0,526,1 +Packing,18.0,574,1 +Packing,20.0,604,1 +Packing,22.0,622,1 +Packing,24.0,638,1 +Packing,26.0,655,1 +Packing,28.0,671,1 +Packing,30.0,687,1 +Packing,32.0,704,1 +Packing,34.0,719,1 +Packing,36.0,736,1 +Packing,38.0,753,1 +Packing,40.0,769,1 +Packing,42.0,785,1 +Packing,44.0,802,1 +Packing,46.0,818,1 +Packing,48.0,834,1 +Packing,50.0,851,1 +Packing,52.0,867,1 +Packing,54.0,883,1 +Packing,56.0,899,1 +Packing,58.0,916,1 +Packing,60.0,932,1 +Packing,62.0,948,1 +Packing,64.0,965,1 +Packing,66.0,981,1 +Packing,68.0,997,1 +Packing,70.0,1014,1 +Packing,72.0,1030,1 +Packing,74.0,1047,1 +Packing,76.0,1063,1 +Packing,78.0,1080,1 +Packing,80.0,1096,1 +Packing,82.0,1112,1 +Packing,84.0,1129,1 +Packing,86.0,1145,1 +Packing,88.0,1161,1 +Packing,90.0,1178,1 +Packing,92.0,1195,1 +Packing,94.0,1211,1 +Packing,96.0,1213,1 +Packing,98.0,1213,1 +Packing,100.0,1213,1 +Packing,102.0,1213,1 +Packing,104.0,1213,1 +Packing,106.0,1213,1 +Packing,108.0,1213,1 +Packing,110.0,1213,1 +Packing,112.0,1213,1 +Packing,114.0,1213,1 +Packing,116.0,1213,1 +Packing,118.0,1213,1 +Packing,120.0,1213,1 +Packing,2.0,76,2 +Packing,4.0,135,2 +Packing,6.0,197,2 +Packing,8.0,266,2 +Packing,10.0,328,2 +Packing,12.0,393,2 +Packing,14.0,462,2 +Packing,16.0,516,2 +Packing,18.0,567,2 +Packing,20.0,603,2 +Packing,22.0,621,2 +Packing,24.0,638,2 +Packing,26.0,654,2 +Packing,28.0,671,2 +Packing,30.0,687,2 +Packing,32.0,703,2 +Packing,34.0,719,2 +Packing,36.0,736,2 +Packing,38.0,752,2 +Packing,40.0,769,2 +Packing,42.0,785,2 +Packing,44.0,802,2 +Packing,46.0,818,2 +Packing,48.0,834,2 +Packing,50.0,851,2 +Packing,52.0,868,2 +Packing,54.0,884,2 +Packing,56.0,901,2 +Packing,58.0,917,2 +Packing,60.0,934,2 +Packing,62.0,950,2 +Packing,64.0,967,2 +Packing,66.0,983,2 +Packing,68.0,1000,2 +Packing,70.0,1016,2 +Packing,72.0,1032,2 +Packing,74.0,1049,2 +Packing,76.0,1066,2 +Packing,78.0,1082,2 +Packing,80.0,1099,2 +Packing,82.0,1115,2 +Packing,84.0,1131,2 +Packing,86.0,1148,2 +Packing,88.0,1164,2 +Packing,90.0,1180,2 +Packing,92.0,1197,2 +Packing,94.0,1213,2 +Packing,96.0,1213,2 +Packing,98.0,1213,2 +Packing,100.0,1213,2 +Packing,102.0,1213,2 +Packing,104.0,1213,2 +Packing,106.0,1213,2 +Packing,108.0,1213,2 +Packing,110.0,1213,2 +Packing,112.0,1213,2 +Packing,114.0,1213,2 +Packing,116.0,1213,2 +Packing,118.0,1213,2 +Packing,120.0,1213,2 +Packing,2.0,78,3 +Packing,4.0,144,3 +Packing,6.0,205,3 +Packing,8.0,272,3 +Packing,10.0,336,3 +Packing,12.0,398,3 +Packing,14.0,466,3 +Packing,16.0,534,3 +Packing,18.0,575,3 +Packing,20.0,605,3 +Packing,22.0,621,3 +Packing,24.0,637,3 +Packing,26.0,653,3 +Packing,28.0,670,3 +Packing,30.0,686,3 +Packing,32.0,702,3 +Packing,34.0,719,3 +Packing,36.0,736,3 +Packing,38.0,752,3 +Packing,40.0,769,3 +Packing,42.0,785,3 +Packing,44.0,801,3 +Packing,46.0,818,3 +Packing,48.0,834,3 +Packing,50.0,850,3 +Packing,52.0,867,3 +Packing,54.0,883,3 +Packing,56.0,899,3 +Packing,58.0,916,3 +Packing,60.0,933,3 +Packing,62.0,949,3 +Packing,64.0,965,3 +Packing,66.0,982,3 +Packing,68.0,998,3 +Packing,70.0,1015,3 +Packing,72.0,1031,3 +Packing,74.0,1047,3 +Packing,76.0,1064,3 +Packing,78.0,1080,3 +Packing,80.0,1097,3 +Packing,82.0,1114,3 +Packing,84.0,1130,3 +Packing,86.0,1147,3 +Packing,88.0,1163,3 +Packing,90.0,1179,3 +Packing,92.0,1196,3 +Packing,94.0,1212,3 +Packing,96.0,1213,3 +Packing,98.0,1213,3 +Packing,100.0,1213,3 +Packing,102.0,1213,3 +Packing,104.0,1213,3 +Packing,106.0,1213,3 +Packing,108.0,1213,3 +Packing,110.0,1213,3 +Packing,112.0,1213,3 +Packing,114.0,1213,3 +Packing,116.0,1213,3 +Packing,118.0,1213,3 +Packing,120.0,1213,3 +Packing,2.0,78,4 +Packing,4.0,138,4 +Packing,6.0,197,4 +Packing,8.0,260,4 +Packing,10.0,322,4 +Packing,12.0,384,4 +Packing,14.0,447,4 +Packing,16.0,514,4 +Packing,18.0,569,4 +Packing,20.0,605,4 +Packing,22.0,622,4 +Packing,24.0,638,4 +Packing,26.0,655,4 +Packing,28.0,671,4 +Packing,30.0,687,4 +Packing,32.0,704,4 +Packing,34.0,720,4 +Packing,36.0,736,4 +Packing,38.0,753,4 +Packing,40.0,769,4 +Packing,42.0,785,4 +Packing,44.0,802,4 +Packing,46.0,818,4 +Packing,48.0,834,4 +Packing,50.0,851,4 +Packing,52.0,867,4 +Packing,54.0,884,4 +Packing,56.0,900,4 +Packing,58.0,916,4 +Packing,60.0,932,4 +Packing,62.0,949,4 +Packing,64.0,965,4 +Packing,66.0,982,4 +Packing,68.0,998,4 +Packing,70.0,1014,4 +Packing,72.0,1031,4 +Packing,74.0,1047,4 +Packing,76.0,1063,4 +Packing,78.0,1080,4 +Packing,80.0,1096,4 +Packing,82.0,1112,4 +Packing,84.0,1129,4 +Packing,86.0,1145,4 +Packing,88.0,1162,4 +Packing,90.0,1178,4 +Packing,92.0,1194,4 +Packing,94.0,1211,4 +Packing,96.0,1213,4 +Packing,98.0,1213,4 +Packing,100.0,1213,4 +Packing,102.0,1213,4 +Packing,104.0,1213,4 +Packing,106.0,1213,4 +Packing,108.0,1213,4 +Packing,110.0,1213,4 +Packing,112.0,1213,4 +Packing,114.0,1213,4 +Packing,116.0,1213,4 +Packing,118.0,1213,4 +Packing,120.0,1213,4 +Packing,2.0,77,5 +Packing,4.0,142,5 +Packing,6.0,204,5 +Packing,8.0,269,5 +Packing,10.0,331,5 +Packing,12.0,389,5 +Packing,14.0,455,5 +Packing,16.0,521,5 +Packing,18.0,571,5 +Packing,20.0,605,5 +Packing,22.0,621,5 +Packing,24.0,637,5 +Packing,26.0,653,5 +Packing,28.0,670,5 +Packing,30.0,686,5 +Packing,32.0,702,5 +Packing,34.0,718,5 +Packing,36.0,735,5 +Packing,38.0,752,5 +Packing,40.0,768,5 +Packing,42.0,784,5 +Packing,44.0,800,5 +Packing,46.0,816,5 +Packing,48.0,833,5 +Packing,50.0,849,5 +Packing,52.0,865,5 +Packing,54.0,882,5 +Packing,56.0,898,5 +Packing,58.0,914,5 +Packing,60.0,931,5 +Packing,62.0,947,5 +Packing,64.0,964,5 +Packing,66.0,980,5 +Packing,68.0,996,5 +Packing,70.0,1012,5 +Packing,72.0,1029,5 +Packing,74.0,1046,5 +Packing,76.0,1062,5 +Packing,78.0,1079,5 +Packing,80.0,1095,5 +Packing,82.0,1111,5 +Packing,84.0,1127,5 +Packing,86.0,1144,5 +Packing,88.0,1160,5 +Packing,90.0,1177,5 +Packing,92.0,1193,5 +Packing,94.0,1210,5 +Packing,96.0,1213,5 +Packing,98.0,1213,5 +Packing,100.0,1213,5 +Packing,102.0,1213,5 +Packing,104.0,1213,5 +Packing,106.0,1213,5 +Packing,108.0,1213,5 +Packing,110.0,1213,5 +Packing,112.0,1213,5 +Packing,114.0,1213,5 +Packing,116.0,1213,5 +Packing,118.0,1213,5 +Packing,120.0,1213,5 +Packing,2.0,77,6 +Packing,4.0,145,6 +Packing,6.0,211,6 +Packing,8.0,269,6 +Packing,10.0,331,6 +Packing,12.0,392,6 +Packing,14.0,467,6 +Packing,16.0,524,6 +Packing,18.0,570,6 +Packing,20.0,606,6 +Packing,22.0,622,6 +Packing,24.0,638,6 +Packing,26.0,655,6 +Packing,28.0,671,6 +Packing,30.0,687,6 +Packing,32.0,704,6 +Packing,34.0,721,6 +Packing,36.0,738,6 +Packing,38.0,754,6 +Packing,40.0,770,6 +Packing,42.0,787,6 +Packing,44.0,803,6 +Packing,46.0,819,6 +Packing,48.0,836,6 +Packing,50.0,852,6 +Packing,52.0,868,6 +Packing,54.0,885,6 +Packing,56.0,901,6 +Packing,58.0,917,6 +Packing,60.0,934,6 +Packing,62.0,950,6 +Packing,64.0,967,6 +Packing,66.0,983,6 +Packing,68.0,999,6 +Packing,70.0,1015,6 +Packing,72.0,1032,6 +Packing,74.0,1049,6 +Packing,76.0,1065,6 +Packing,78.0,1081,6 +Packing,80.0,1098,6 +Packing,82.0,1114,6 +Packing,84.0,1130,6 +Packing,86.0,1146,6 +Packing,88.0,1163,6 +Packing,90.0,1179,6 +Packing,92.0,1196,6 +Packing,94.0,1212,6 +Packing,96.0,1213,6 +Packing,98.0,1213,6 +Packing,100.0,1213,6 +Packing,102.0,1213,6 +Packing,104.0,1213,6 +Packing,106.0,1213,6 +Packing,108.0,1213,6 +Packing,110.0,1213,6 +Packing,112.0,1213,6 +Packing,114.0,1213,6 +Packing,116.0,1213,6 +Packing,118.0,1213,6 +Packing,120.0,1213,6 +Packing,2.0,77,7 +Packing,4.0,140,7 +Packing,6.0,195,7 +Packing,8.0,262,7 +Packing,10.0,328,7 +Packing,12.0,389,7 +Packing,14.0,461,7 +Packing,16.0,527,7 +Packing,18.0,574,7 +Packing,20.0,606,7 +Packing,22.0,622,7 +Packing,24.0,639,7 +Packing,26.0,655,7 +Packing,28.0,671,7 +Packing,30.0,687,7 +Packing,32.0,704,7 +Packing,34.0,720,7 +Packing,36.0,737,7 +Packing,38.0,753,7 +Packing,40.0,769,7 +Packing,42.0,785,7 +Packing,44.0,802,7 +Packing,46.0,818,7 +Packing,48.0,834,7 +Packing,50.0,850,7 +Packing,52.0,867,7 +Packing,54.0,884,7 +Packing,56.0,900,7 +Packing,58.0,917,7 +Packing,60.0,933,7 +Packing,62.0,950,7 +Packing,64.0,966,7 +Packing,66.0,982,7 +Packing,68.0,999,7 +Packing,70.0,1015,7 +Packing,72.0,1031,7 +Packing,74.0,1048,7 +Packing,76.0,1065,7 +Packing,78.0,1081,7 +Packing,80.0,1098,7 +Packing,82.0,1114,7 +Packing,84.0,1131,7 +Packing,86.0,1147,7 +Packing,88.0,1163,7 +Packing,90.0,1180,7 +Packing,92.0,1197,7 +Packing,94.0,1213,7 +Packing,96.0,1213,7 +Packing,98.0,1213,7 +Packing,100.0,1213,7 +Packing,102.0,1213,7 +Packing,104.0,1213,7 +Packing,106.0,1213,7 +Packing,108.0,1213,7 +Packing,110.0,1213,7 +Packing,112.0,1213,7 +Packing,114.0,1213,7 +Packing,116.0,1213,7 +Packing,118.0,1213,7 +Packing,120.0,1213,7 +Packing,2.0,81,8 +Packing,4.0,141,8 +Packing,6.0,207,8 +Packing,8.0,270,8 +Packing,10.0,332,8 +Packing,12.0,395,8 +Packing,14.0,458,8 +Packing,16.0,518,8 +Packing,18.0,570,8 +Packing,20.0,603,8 +Packing,22.0,621,8 +Packing,24.0,637,8 +Packing,26.0,654,8 +Packing,28.0,671,8 +Packing,30.0,686,8 +Packing,32.0,703,8 +Packing,34.0,719,8 +Packing,36.0,736,8 +Packing,38.0,753,8 +Packing,40.0,769,8 +Packing,42.0,785,8 +Packing,44.0,801,8 +Packing,46.0,818,8 +Packing,48.0,834,8 +Packing,50.0,851,8 +Packing,52.0,867,8 +Packing,54.0,883,8 +Packing,56.0,899,8 +Packing,58.0,916,8 +Packing,60.0,932,8 +Packing,62.0,949,8 +Packing,64.0,965,8 +Packing,66.0,981,8 +Packing,68.0,998,8 +Packing,70.0,1014,8 +Packing,72.0,1031,8 +Packing,74.0,1047,8 +Packing,76.0,1064,8 +Packing,78.0,1080,8 +Packing,80.0,1096,8 +Packing,82.0,1112,8 +Packing,84.0,1128,8 +Packing,86.0,1145,8 +Packing,88.0,1161,8 +Packing,90.0,1177,8 +Packing,92.0,1194,8 +Packing,94.0,1210,8 +Packing,96.0,1213,8 +Packing,98.0,1213,8 +Packing,100.0,1213,8 +Packing,102.0,1213,8 +Packing,104.0,1213,8 +Packing,106.0,1213,8 +Packing,108.0,1213,8 +Packing,110.0,1213,8 +Packing,112.0,1213,8 +Packing,114.0,1213,8 +Packing,116.0,1213,8 +Packing,118.0,1213,8 +Packing,120.0,1213,8 +Packing,2.0,78,9 +Packing,4.0,144,9 +Packing,6.0,205,9 +Packing,8.0,263,9 +Packing,10.0,322,9 +Packing,12.0,383,9 +Packing,14.0,442,9 +Packing,16.0,511,9 +Packing,18.0,568,9 +Packing,20.0,602,9 +Packing,22.0,621,9 +Packing,24.0,637,9 +Packing,26.0,654,9 +Packing,28.0,670,9 +Packing,30.0,686,9 +Packing,32.0,703,9 +Packing,34.0,719,9 +Packing,36.0,736,9 +Packing,38.0,753,9 +Packing,40.0,769,9 +Packing,42.0,785,9 +Packing,44.0,802,9 +Packing,46.0,818,9 +Packing,48.0,835,9 +Packing,50.0,851,9 +Packing,52.0,867,9 +Packing,54.0,884,9 +Packing,56.0,900,9 +Packing,58.0,916,9 +Packing,60.0,933,9 +Packing,62.0,949,9 +Packing,64.0,965,9 +Packing,66.0,982,9 +Packing,68.0,999,9 +Packing,70.0,1015,9 +Packing,72.0,1032,9 +Packing,74.0,1049,9 +Packing,76.0,1065,9 +Packing,78.0,1082,9 +Packing,80.0,1098,9 +Packing,82.0,1113,9 +Packing,84.0,1130,9 +Packing,86.0,1146,9 +Packing,88.0,1162,9 +Packing,90.0,1178,9 +Packing,92.0,1194,9 +Packing,94.0,1210,9 +Packing,96.0,1213,9 +Packing,98.0,1213,9 +Packing,100.0,1213,9 +Packing,102.0,1213,9 +Packing,104.0,1213,9 +Packing,106.0,1213,9 +Packing,108.0,1213,9 +Packing,110.0,1213,9 +Packing,112.0,1213,9 +Packing,114.0,1213,9 +Packing,116.0,1213,9 +Packing,118.0,1213,9 +Packing,120.0,1213,9 +Clustering,2.0,80,0 +Clustering,4.0,148,0 +Clustering,6.0,211,0 +Clustering,8.0,279,0 +Clustering,10.0,345,0 +Clustering,12.0,410,0 +Clustering,14.0,477,0 +Clustering,16.0,533,0 +Clustering,18.0,574,0 +Clustering,20.0,605,0 +Clustering,22.0,622,0 +Clustering,24.0,638,0 +Clustering,26.0,655,0 +Clustering,28.0,671,0 +Clustering,30.0,687,0 +Clustering,32.0,704,0 +Clustering,34.0,719,0 +Clustering,36.0,736,0 +Clustering,38.0,753,0 +Clustering,40.0,769,0 +Clustering,42.0,786,0 +Clustering,44.0,802,0 +Clustering,46.0,819,0 +Clustering,48.0,836,0 +Clustering,50.0,852,0 +Clustering,52.0,869,0 +Clustering,54.0,885,0 +Clustering,56.0,901,0 +Clustering,58.0,918,0 +Clustering,60.0,934,0 +Clustering,62.0,950,0 +Clustering,64.0,967,0 +Clustering,66.0,983,0 +Clustering,68.0,1000,0 +Clustering,70.0,1016,0 +Clustering,72.0,1032,0 +Clustering,74.0,1049,0 +Clustering,76.0,1065,0 +Clustering,78.0,1082,0 +Clustering,80.0,1098,0 +Clustering,82.0,1114,0 +Clustering,84.0,1130,0 +Clustering,86.0,1146,0 +Clustering,88.0,1163,0 +Clustering,90.0,1179,0 +Clustering,92.0,1196,0 +Clustering,94.0,1212,0 +Clustering,96.0,1213,0 +Clustering,98.0,1213,0 +Clustering,100.0,1213,0 +Clustering,102.0,1213,0 +Clustering,104.0,1213,0 +Clustering,106.0,1213,0 +Clustering,108.0,1213,0 +Clustering,110.0,1213,0 +Clustering,112.0,1213,0 +Clustering,114.0,1213,0 +Clustering,116.0,1213,0 +Clustering,118.0,1213,0 +Clustering,120.0,1213,0 +Clustering,2.0,79,1 +Clustering,4.0,143,1 +Clustering,6.0,209,1 +Clustering,8.0,274,1 +Clustering,10.0,334,1 +Clustering,12.0,394,1 +Clustering,14.0,461,1 +Clustering,16.0,527,1 +Clustering,18.0,574,1 +Clustering,20.0,606,1 +Clustering,22.0,622,1 +Clustering,24.0,639,1 +Clustering,26.0,655,1 +Clustering,28.0,672,1 +Clustering,30.0,688,1 +Clustering,32.0,704,1 +Clustering,34.0,720,1 +Clustering,36.0,737,1 +Clustering,38.0,754,1 +Clustering,40.0,770,1 +Clustering,42.0,786,1 +Clustering,44.0,802,1 +Clustering,46.0,818,1 +Clustering,48.0,834,1 +Clustering,50.0,851,1 +Clustering,52.0,867,1 +Clustering,54.0,883,1 +Clustering,56.0,900,1 +Clustering,58.0,916,1 +Clustering,60.0,932,1 +Clustering,62.0,948,1 +Clustering,64.0,965,1 +Clustering,66.0,981,1 +Clustering,68.0,997,1 +Clustering,70.0,1014,1 +Clustering,72.0,1030,1 +Clustering,74.0,1047,1 +Clustering,76.0,1063,1 +Clustering,78.0,1080,1 +Clustering,80.0,1096,1 +Clustering,82.0,1112,1 +Clustering,84.0,1129,1 +Clustering,86.0,1144,1 +Clustering,88.0,1161,1 +Clustering,90.0,1178,1 +Clustering,92.0,1194,1 +Clustering,94.0,1211,1 +Clustering,96.0,1213,1 +Clustering,98.0,1213,1 +Clustering,100.0,1213,1 +Clustering,102.0,1213,1 +Clustering,104.0,1213,1 +Clustering,106.0,1213,1 +Clustering,108.0,1213,1 +Clustering,110.0,1213,1 +Clustering,112.0,1213,1 +Clustering,114.0,1213,1 +Clustering,116.0,1213,1 +Clustering,118.0,1213,1 +Clustering,120.0,1213,1 +Clustering,2.0,76,2 +Clustering,4.0,135,2 +Clustering,6.0,197,2 +Clustering,8.0,266,2 +Clustering,10.0,328,2 +Clustering,12.0,393,2 +Clustering,14.0,463,2 +Clustering,16.0,517,2 +Clustering,18.0,568,2 +Clustering,20.0,605,2 +Clustering,22.0,622,2 +Clustering,24.0,638,2 +Clustering,26.0,655,2 +Clustering,28.0,672,2 +Clustering,30.0,688,2 +Clustering,32.0,704,2 +Clustering,34.0,720,2 +Clustering,36.0,737,2 +Clustering,38.0,753,2 +Clustering,40.0,770,2 +Clustering,42.0,786,2 +Clustering,44.0,803,2 +Clustering,46.0,819,2 +Clustering,48.0,836,2 +Clustering,50.0,852,2 +Clustering,52.0,869,2 +Clustering,54.0,886,2 +Clustering,56.0,902,2 +Clustering,58.0,918,2 +Clustering,60.0,935,2 +Clustering,62.0,951,2 +Clustering,64.0,968,2 +Clustering,66.0,984,2 +Clustering,68.0,1001,2 +Clustering,70.0,1017,2 +Clustering,72.0,1034,2 +Clustering,74.0,1051,2 +Clustering,76.0,1067,2 +Clustering,78.0,1084,2 +Clustering,80.0,1100,2 +Clustering,82.0,1116,2 +Clustering,84.0,1132,2 +Clustering,86.0,1148,2 +Clustering,88.0,1165,2 +Clustering,90.0,1181,2 +Clustering,92.0,1198,2 +Clustering,94.0,1213,2 +Clustering,96.0,1213,2 +Clustering,98.0,1213,2 +Clustering,100.0,1213,2 +Clustering,102.0,1213,2 +Clustering,104.0,1213,2 +Clustering,106.0,1213,2 +Clustering,108.0,1213,2 +Clustering,110.0,1213,2 +Clustering,112.0,1213,2 +Clustering,114.0,1213,2 +Clustering,116.0,1213,2 +Clustering,118.0,1213,2 +Clustering,120.0,1213,2 +Clustering,2.0,78,3 +Clustering,4.0,144,3 +Clustering,6.0,205,3 +Clustering,8.0,272,3 +Clustering,10.0,336,3 +Clustering,12.0,398,3 +Clustering,14.0,468,3 +Clustering,16.0,534,3 +Clustering,18.0,575,3 +Clustering,20.0,605,3 +Clustering,22.0,621,3 +Clustering,24.0,637,3 +Clustering,26.0,654,3 +Clustering,28.0,670,3 +Clustering,30.0,686,3 +Clustering,32.0,703,3 +Clustering,34.0,719,3 +Clustering,36.0,736,3 +Clustering,38.0,753,3 +Clustering,40.0,770,3 +Clustering,42.0,786,3 +Clustering,44.0,802,3 +Clustering,46.0,818,3 +Clustering,48.0,835,3 +Clustering,50.0,851,3 +Clustering,52.0,867,3 +Clustering,54.0,884,3 +Clustering,56.0,900,3 +Clustering,58.0,916,3 +Clustering,60.0,933,3 +Clustering,62.0,950,3 +Clustering,64.0,966,3 +Clustering,66.0,983,3 +Clustering,68.0,999,3 +Clustering,70.0,1016,3 +Clustering,72.0,1032,3 +Clustering,74.0,1048,3 +Clustering,76.0,1065,3 +Clustering,78.0,1081,3 +Clustering,80.0,1098,3 +Clustering,82.0,1114,3 +Clustering,84.0,1131,3 +Clustering,86.0,1147,3 +Clustering,88.0,1163,3 +Clustering,90.0,1180,3 +Clustering,92.0,1196,3 +Clustering,94.0,1213,3 +Clustering,96.0,1213,3 +Clustering,98.0,1213,3 +Clustering,100.0,1213,3 +Clustering,102.0,1213,3 +Clustering,104.0,1213,3 +Clustering,106.0,1213,3 +Clustering,108.0,1213,3 +Clustering,110.0,1213,3 +Clustering,112.0,1213,3 +Clustering,114.0,1213,3 +Clustering,116.0,1213,3 +Clustering,118.0,1213,3 +Clustering,120.0,1213,3 +Clustering,2.0,78,4 +Clustering,4.0,138,4 +Clustering,6.0,198,4 +Clustering,8.0,261,4 +Clustering,10.0,322,4 +Clustering,12.0,384,4 +Clustering,14.0,447,4 +Clustering,16.0,514,4 +Clustering,18.0,569,4 +Clustering,20.0,604,4 +Clustering,22.0,622,4 +Clustering,24.0,638,4 +Clustering,26.0,655,4 +Clustering,28.0,670,4 +Clustering,30.0,687,4 +Clustering,32.0,703,4 +Clustering,34.0,719,4 +Clustering,36.0,736,4 +Clustering,38.0,752,4 +Clustering,40.0,769,4 +Clustering,42.0,785,4 +Clustering,44.0,801,4 +Clustering,46.0,818,4 +Clustering,48.0,834,4 +Clustering,50.0,850,4 +Clustering,52.0,867,4 +Clustering,54.0,883,4 +Clustering,56.0,900,4 +Clustering,58.0,916,4 +Clustering,60.0,932,4 +Clustering,62.0,949,4 +Clustering,64.0,965,4 +Clustering,66.0,982,4 +Clustering,68.0,997,4 +Clustering,70.0,1014,4 +Clustering,72.0,1030,4 +Clustering,74.0,1047,4 +Clustering,76.0,1063,4 +Clustering,78.0,1080,4 +Clustering,80.0,1096,4 +Clustering,82.0,1112,4 +Clustering,84.0,1129,4 +Clustering,86.0,1145,4 +Clustering,88.0,1162,4 +Clustering,90.0,1178,4 +Clustering,92.0,1194,4 +Clustering,94.0,1211,4 +Clustering,96.0,1213,4 +Clustering,98.0,1213,4 +Clustering,100.0,1213,4 +Clustering,102.0,1213,4 +Clustering,104.0,1213,4 +Clustering,106.0,1213,4 +Clustering,108.0,1213,4 +Clustering,110.0,1213,4 +Clustering,112.0,1213,4 +Clustering,114.0,1213,4 +Clustering,116.0,1213,4 +Clustering,118.0,1213,4 +Clustering,120.0,1213,4 +Clustering,2.0,77,5 +Clustering,4.0,142,5 +Clustering,6.0,204,5 +Clustering,8.0,269,5 +Clustering,10.0,331,5 +Clustering,12.0,389,5 +Clustering,14.0,455,5 +Clustering,16.0,521,5 +Clustering,18.0,571,5 +Clustering,20.0,604,5 +Clustering,22.0,621,5 +Clustering,24.0,637,5 +Clustering,26.0,653,5 +Clustering,28.0,670,5 +Clustering,30.0,686,5 +Clustering,32.0,702,5 +Clustering,34.0,718,5 +Clustering,36.0,735,5 +Clustering,38.0,752,5 +Clustering,40.0,768,5 +Clustering,42.0,784,5 +Clustering,44.0,800,5 +Clustering,46.0,817,5 +Clustering,48.0,834,5 +Clustering,50.0,850,5 +Clustering,52.0,866,5 +Clustering,54.0,883,5 +Clustering,56.0,898,5 +Clustering,58.0,915,5 +Clustering,60.0,931,5 +Clustering,62.0,947,5 +Clustering,64.0,964,5 +Clustering,66.0,980,5 +Clustering,68.0,996,5 +Clustering,70.0,1013,5 +Clustering,72.0,1029,5 +Clustering,74.0,1046,5 +Clustering,76.0,1062,5 +Clustering,78.0,1079,5 +Clustering,80.0,1095,5 +Clustering,82.0,1111,5 +Clustering,84.0,1127,5 +Clustering,86.0,1144,5 +Clustering,88.0,1161,5 +Clustering,90.0,1177,5 +Clustering,92.0,1194,5 +Clustering,94.0,1210,5 +Clustering,96.0,1213,5 +Clustering,98.0,1213,5 +Clustering,100.0,1213,5 +Clustering,102.0,1213,5 +Clustering,104.0,1213,5 +Clustering,106.0,1213,5 +Clustering,108.0,1213,5 +Clustering,110.0,1213,5 +Clustering,112.0,1213,5 +Clustering,114.0,1213,5 +Clustering,116.0,1213,5 +Clustering,118.0,1213,5 +Clustering,120.0,1213,5 +Clustering,2.0,77,6 +Clustering,4.0,145,6 +Clustering,6.0,211,6 +Clustering,8.0,270,6 +Clustering,10.0,332,6 +Clustering,12.0,393,6 +Clustering,14.0,466,6 +Clustering,16.0,525,6 +Clustering,18.0,571,6 +Clustering,20.0,606,6 +Clustering,22.0,622,6 +Clustering,24.0,638,6 +Clustering,26.0,655,6 +Clustering,28.0,671,6 +Clustering,30.0,687,6 +Clustering,32.0,703,6 +Clustering,34.0,720,6 +Clustering,36.0,736,6 +Clustering,38.0,753,6 +Clustering,40.0,770,6 +Clustering,42.0,786,6 +Clustering,44.0,802,6 +Clustering,46.0,819,6 +Clustering,48.0,835,6 +Clustering,50.0,851,6 +Clustering,52.0,868,6 +Clustering,54.0,884,6 +Clustering,56.0,900,6 +Clustering,58.0,917,6 +Clustering,60.0,933,6 +Clustering,62.0,949,6 +Clustering,64.0,966,6 +Clustering,66.0,982,6 +Clustering,68.0,998,6 +Clustering,70.0,1014,6 +Clustering,72.0,1031,6 +Clustering,74.0,1047,6 +Clustering,76.0,1064,6 +Clustering,78.0,1080,6 +Clustering,80.0,1096,6 +Clustering,82.0,1113,6 +Clustering,84.0,1128,6 +Clustering,86.0,1144,6 +Clustering,88.0,1161,6 +Clustering,90.0,1178,6 +Clustering,92.0,1194,6 +Clustering,94.0,1211,6 +Clustering,96.0,1213,6 +Clustering,98.0,1213,6 +Clustering,100.0,1213,6 +Clustering,102.0,1213,6 +Clustering,104.0,1213,6 +Clustering,106.0,1213,6 +Clustering,108.0,1213,6 +Clustering,110.0,1213,6 +Clustering,112.0,1213,6 +Clustering,114.0,1213,6 +Clustering,116.0,1213,6 +Clustering,118.0,1213,6 +Clustering,120.0,1213,6 +Clustering,2.0,76,7 +Clustering,4.0,140,7 +Clustering,6.0,195,7 +Clustering,8.0,262,7 +Clustering,10.0,328,7 +Clustering,12.0,389,7 +Clustering,14.0,461,7 +Clustering,16.0,526,7 +Clustering,18.0,574,7 +Clustering,20.0,606,7 +Clustering,22.0,622,7 +Clustering,24.0,638,7 +Clustering,26.0,655,7 +Clustering,28.0,671,7 +Clustering,30.0,687,7 +Clustering,32.0,703,7 +Clustering,34.0,720,7 +Clustering,36.0,737,7 +Clustering,38.0,753,7 +Clustering,40.0,769,7 +Clustering,42.0,786,7 +Clustering,44.0,802,7 +Clustering,46.0,818,7 +Clustering,48.0,834,7 +Clustering,50.0,850,7 +Clustering,52.0,867,7 +Clustering,54.0,884,7 +Clustering,56.0,900,7 +Clustering,58.0,917,7 +Clustering,60.0,933,7 +Clustering,62.0,950,7 +Clustering,64.0,966,7 +Clustering,66.0,982,7 +Clustering,68.0,999,7 +Clustering,70.0,1015,7 +Clustering,72.0,1031,7 +Clustering,74.0,1048,7 +Clustering,76.0,1065,7 +Clustering,78.0,1081,7 +Clustering,80.0,1098,7 +Clustering,82.0,1114,7 +Clustering,84.0,1131,7 +Clustering,86.0,1147,7 +Clustering,88.0,1163,7 +Clustering,90.0,1180,7 +Clustering,92.0,1197,7 +Clustering,94.0,1213,7 +Clustering,96.0,1213,7 +Clustering,98.0,1213,7 +Clustering,100.0,1213,7 +Clustering,102.0,1213,7 +Clustering,104.0,1213,7 +Clustering,106.0,1213,7 +Clustering,108.0,1213,7 +Clustering,110.0,1213,7 +Clustering,112.0,1213,7 +Clustering,114.0,1213,7 +Clustering,116.0,1213,7 +Clustering,118.0,1213,7 +Clustering,120.0,1213,7 +Clustering,2.0,80,8 +Clustering,4.0,141,8 +Clustering,6.0,207,8 +Clustering,8.0,270,8 +Clustering,10.0,332,8 +Clustering,12.0,395,8 +Clustering,14.0,460,8 +Clustering,16.0,520,8 +Clustering,18.0,572,8 +Clustering,20.0,605,8 +Clustering,22.0,622,8 +Clustering,24.0,638,8 +Clustering,26.0,655,8 +Clustering,28.0,672,8 +Clustering,30.0,687,8 +Clustering,32.0,704,8 +Clustering,34.0,720,8 +Clustering,36.0,737,8 +Clustering,38.0,754,8 +Clustering,40.0,770,8 +Clustering,42.0,786,8 +Clustering,44.0,802,8 +Clustering,46.0,819,8 +Clustering,48.0,835,8 +Clustering,50.0,852,8 +Clustering,52.0,868,8 +Clustering,54.0,884,8 +Clustering,56.0,900,8 +Clustering,58.0,917,8 +Clustering,60.0,933,8 +Clustering,62.0,950,8 +Clustering,64.0,966,8 +Clustering,66.0,983,8 +Clustering,68.0,999,8 +Clustering,70.0,1016,8 +Clustering,72.0,1032,8 +Clustering,74.0,1048,8 +Clustering,76.0,1065,8 +Clustering,78.0,1081,8 +Clustering,80.0,1097,8 +Clustering,82.0,1114,8 +Clustering,84.0,1130,8 +Clustering,86.0,1146,8 +Clustering,88.0,1162,8 +Clustering,90.0,1179,8 +Clustering,92.0,1196,8 +Clustering,94.0,1211,8 +Clustering,96.0,1213,8 +Clustering,98.0,1213,8 +Clustering,100.0,1213,8 +Clustering,102.0,1213,8 +Clustering,104.0,1213,8 +Clustering,106.0,1213,8 +Clustering,108.0,1213,8 +Clustering,110.0,1213,8 +Clustering,112.0,1213,8 +Clustering,114.0,1213,8 +Clustering,116.0,1213,8 +Clustering,118.0,1213,8 +Clustering,120.0,1213,8 +Clustering,2.0,79,9 +Clustering,4.0,144,9 +Clustering,6.0,206,9 +Clustering,8.0,264,9 +Clustering,10.0,324,9 +Clustering,12.0,385,9 +Clustering,14.0,443,9 +Clustering,16.0,512,9 +Clustering,18.0,570,9 +Clustering,20.0,602,9 +Clustering,22.0,621,9 +Clustering,24.0,637,9 +Clustering,26.0,654,9 +Clustering,28.0,670,9 +Clustering,30.0,686,9 +Clustering,32.0,703,9 +Clustering,34.0,719,9 +Clustering,36.0,736,9 +Clustering,38.0,753,9 +Clustering,40.0,769,9 +Clustering,42.0,785,9 +Clustering,44.0,802,9 +Clustering,46.0,818,9 +Clustering,48.0,834,9 +Clustering,50.0,851,9 +Clustering,52.0,867,9 +Clustering,54.0,883,9 +Clustering,56.0,900,9 +Clustering,58.0,916,9 +Clustering,60.0,933,9 +Clustering,62.0,949,9 +Clustering,64.0,966,9 +Clustering,66.0,982,9 +Clustering,68.0,999,9 +Clustering,70.0,1016,9 +Clustering,72.0,1032,9 +Clustering,74.0,1049,9 +Clustering,76.0,1065,9 +Clustering,78.0,1082,9 +Clustering,80.0,1098,9 +Clustering,82.0,1113,9 +Clustering,84.0,1130,9 +Clustering,86.0,1146,9 +Clustering,88.0,1162,9 +Clustering,90.0,1178,9 +Clustering,92.0,1194,9 +Clustering,94.0,1210,9 +Clustering,96.0,1213,9 +Clustering,98.0,1213,9 +Clustering,100.0,1213,9 +Clustering,102.0,1213,9 +Clustering,104.0,1213,9 +Clustering,106.0,1213,9 +Clustering,108.0,1213,9 +Clustering,110.0,1213,9 +Clustering,112.0,1213,9 +Clustering,114.0,1213,9 +Clustering,116.0,1213,9 +Clustering,118.0,1213,9 +Clustering,120.0,1213,9 +FGD,2.0,55,0 +FGD,4.0,74,0 +FGD,6.0,92,0 +FGD,8.0,118,0 +FGD,10.0,137,0 +FGD,12.0,172,0 +FGD,14.0,192,0 +FGD,16.0,210,0 +FGD,18.0,242,0 +FGD,20.0,267,0 +FGD,22.0,291,0 +FGD,24.0,312,0 +FGD,26.0,335,0 +FGD,28.0,355,0 +FGD,30.0,375,0 +FGD,32.0,394,0 +FGD,34.0,424,0 +FGD,36.0,454,0 +FGD,38.0,483,0 +FGD,40.0,501,0 +FGD,42.0,525,0 +FGD,44.0,545,0 +FGD,46.0,572,0 +FGD,48.0,596,0 +FGD,50.0,633,0 +FGD,52.0,671,0 +FGD,54.0,689,0 +FGD,56.0,721,0 +FGD,58.0,754,0 +FGD,60.0,782,0 +FGD,62.0,807,0 +FGD,64.0,826,0 +FGD,66.0,843,0 +FGD,68.0,864,0 +FGD,70.0,894,0 +FGD,72.0,915,0 +FGD,74.0,936,0 +FGD,76.0,965,0 +FGD,78.0,986,0 +FGD,80.0,1007,0 +FGD,82.0,1033,0 +FGD,84.0,1053,0 +FGD,86.0,1085,0 +FGD,88.0,1113,0 +FGD,90.0,1145,0 +FGD,92.0,1186,0 +FGD,94.0,1213,0 +FGD,96.0,1213,0 +FGD,98.0,1213,0 +FGD,100.0,1213,0 +FGD,102.0,1213,0 +FGD,104.0,1213,0 +FGD,106.0,1213,0 +FGD,108.0,1213,0 +FGD,110.0,1213,0 +FGD,112.0,1213,0 +FGD,114.0,1213,0 +FGD,116.0,1213,0 +FGD,118.0,1213,0 +FGD,120.0,1213,0 +FGD,2.0,55,1 +FGD,4.0,74,1 +FGD,6.0,97,1 +FGD,8.0,119,1 +FGD,10.0,140,1 +FGD,12.0,174,1 +FGD,14.0,193,1 +FGD,16.0,212,1 +FGD,18.0,243,1 +FGD,20.0,270,1 +FGD,22.0,293,1 +FGD,24.0,313,1 +FGD,26.0,340,1 +FGD,28.0,357,1 +FGD,30.0,375,1 +FGD,32.0,395,1 +FGD,34.0,424,1 +FGD,36.0,455,1 +FGD,38.0,482,1 +FGD,40.0,500,1 +FGD,42.0,523,1 +FGD,44.0,540,1 +FGD,46.0,566,1 +FGD,48.0,591,1 +FGD,50.0,626,1 +FGD,52.0,665,1 +FGD,54.0,684,1 +FGD,56.0,710,1 +FGD,58.0,750,1 +FGD,60.0,776,1 +FGD,62.0,802,1 +FGD,64.0,821,1 +FGD,66.0,838,1 +FGD,68.0,856,1 +FGD,70.0,874,1 +FGD,72.0,907,1 +FGD,74.0,926,1 +FGD,76.0,950,1 +FGD,78.0,979,1 +FGD,80.0,999,1 +FGD,82.0,1019,1 +FGD,84.0,1045,1 +FGD,86.0,1071,1 +FGD,88.0,1100,1 +FGD,90.0,1136,1 +FGD,92.0,1170,1 +FGD,94.0,1205,1 +FGD,96.0,1213,1 +FGD,98.0,1213,1 +FGD,100.0,1213,1 +FGD,102.0,1213,1 +FGD,104.0,1213,1 +FGD,106.0,1213,1 +FGD,108.0,1213,1 +FGD,110.0,1213,1 +FGD,112.0,1213,1 +FGD,114.0,1213,1 +FGD,116.0,1213,1 +FGD,118.0,1213,1 +FGD,120.0,1213,1 +FGD,2.0,55,2 +FGD,4.0,74,2 +FGD,6.0,93,2 +FGD,8.0,118,2 +FGD,10.0,136,2 +FGD,12.0,170,2 +FGD,14.0,192,2 +FGD,16.0,211,2 +FGD,18.0,240,2 +FGD,20.0,267,2 +FGD,22.0,291,2 +FGD,24.0,310,2 +FGD,26.0,333,2 +FGD,28.0,353,2 +FGD,30.0,373,2 +FGD,32.0,392,2 +FGD,34.0,421,2 +FGD,36.0,453,2 +FGD,38.0,481,2 +FGD,40.0,500,2 +FGD,42.0,524,2 +FGD,44.0,540,2 +FGD,46.0,567,2 +FGD,48.0,593,2 +FGD,50.0,630,2 +FGD,52.0,667,2 +FGD,54.0,683,2 +FGD,56.0,712,2 +FGD,58.0,751,2 +FGD,60.0,777,2 +FGD,62.0,803,2 +FGD,64.0,822,2 +FGD,66.0,839,2 +FGD,68.0,858,2 +FGD,70.0,876,2 +FGD,72.0,908,2 +FGD,74.0,930,2 +FGD,76.0,953,2 +FGD,78.0,982,2 +FGD,80.0,1002,2 +FGD,82.0,1024,2 +FGD,84.0,1045,2 +FGD,86.0,1073,2 +FGD,88.0,1098,2 +FGD,90.0,1136,2 +FGD,92.0,1170,2 +FGD,94.0,1205,2 +FGD,96.0,1213,2 +FGD,98.0,1213,2 +FGD,100.0,1213,2 +FGD,102.0,1213,2 +FGD,104.0,1213,2 +FGD,106.0,1213,2 +FGD,108.0,1213,2 +FGD,110.0,1213,2 +FGD,112.0,1213,2 +FGD,114.0,1213,2 +FGD,116.0,1213,2 +FGD,118.0,1213,2 +FGD,120.0,1213,2 +FGD,2.0,55,3 +FGD,4.0,73,3 +FGD,6.0,98,3 +FGD,8.0,121,3 +FGD,10.0,154,3 +FGD,12.0,181,3 +FGD,14.0,201,3 +FGD,16.0,225,3 +FGD,18.0,255,3 +FGD,20.0,281,3 +FGD,22.0,300,3 +FGD,24.0,325,3 +FGD,26.0,346,3 +FGD,28.0,363,3 +FGD,30.0,382,3 +FGD,32.0,410,3 +FGD,34.0,443,3 +FGD,36.0,465,3 +FGD,38.0,489,3 +FGD,40.0,513,3 +FGD,42.0,531,3 +FGD,44.0,556,3 +FGD,46.0,578,3 +FGD,48.0,603,3 +FGD,50.0,640,3 +FGD,52.0,675,3 +FGD,54.0,695,3 +FGD,56.0,732,3 +FGD,58.0,762,3 +FGD,60.0,794,3 +FGD,62.0,816,3 +FGD,64.0,831,3 +FGD,66.0,849,3 +FGD,68.0,869,3 +FGD,70.0,901,3 +FGD,72.0,920,3 +FGD,74.0,942,3 +FGD,76.0,969,3 +FGD,78.0,989,3 +FGD,80.0,1013,3 +FGD,82.0,1039,3 +FGD,84.0,1061,3 +FGD,86.0,1090,3 +FGD,88.0,1121,3 +FGD,90.0,1157,3 +FGD,92.0,1194,3 +FGD,94.0,1213,3 +FGD,96.0,1213,3 +FGD,98.0,1213,3 +FGD,100.0,1213,3 +FGD,102.0,1213,3 +FGD,104.0,1213,3 +FGD,106.0,1213,3 +FGD,108.0,1213,3 +FGD,110.0,1213,3 +FGD,112.0,1213,3 +FGD,114.0,1213,3 +FGD,116.0,1213,3 +FGD,118.0,1213,3 +FGD,120.0,1213,3 +FGD,2.0,55,4 +FGD,4.0,74,4 +FGD,6.0,93,4 +FGD,8.0,118,4 +FGD,10.0,138,4 +FGD,12.0,172,4 +FGD,14.0,192,4 +FGD,16.0,212,4 +FGD,18.0,243,4 +FGD,20.0,269,4 +FGD,22.0,291,4 +FGD,24.0,311,4 +FGD,26.0,336,4 +FGD,28.0,355,4 +FGD,30.0,373,4 +FGD,32.0,392,4 +FGD,34.0,422,4 +FGD,36.0,453,4 +FGD,38.0,481,4 +FGD,40.0,497,4 +FGD,42.0,522,4 +FGD,44.0,539,4 +FGD,46.0,565,4 +FGD,48.0,590,4 +FGD,50.0,626,4 +FGD,52.0,665,4 +FGD,54.0,682,4 +FGD,56.0,709,4 +FGD,58.0,749,4 +FGD,60.0,777,4 +FGD,62.0,803,4 +FGD,64.0,822,4 +FGD,66.0,839,4 +FGD,68.0,857,4 +FGD,70.0,876,4 +FGD,72.0,907,4 +FGD,74.0,929,4 +FGD,76.0,950,4 +FGD,78.0,979,4 +FGD,80.0,998,4 +FGD,82.0,1019,4 +FGD,84.0,1044,4 +FGD,86.0,1072,4 +FGD,88.0,1097,4 +FGD,90.0,1134,4 +FGD,92.0,1168,4 +FGD,94.0,1204,4 +FGD,96.0,1213,4 +FGD,98.0,1213,4 +FGD,100.0,1213,4 +FGD,102.0,1213,4 +FGD,104.0,1213,4 +FGD,106.0,1213,4 +FGD,108.0,1213,4 +FGD,110.0,1213,4 +FGD,112.0,1213,4 +FGD,114.0,1213,4 +FGD,116.0,1213,4 +FGD,118.0,1213,4 +FGD,120.0,1213,4 +FGD,2.0,55,5 +FGD,4.0,74,5 +FGD,6.0,93,5 +FGD,8.0,118,5 +FGD,10.0,138,5 +FGD,12.0,173,5 +FGD,14.0,193,5 +FGD,16.0,212,5 +FGD,18.0,243,5 +FGD,20.0,269,5 +FGD,22.0,294,5 +FGD,24.0,314,5 +FGD,26.0,340,5 +FGD,28.0,357,5 +FGD,30.0,375,5 +FGD,32.0,396,5 +FGD,34.0,424,5 +FGD,36.0,456,5 +FGD,38.0,482,5 +FGD,40.0,502,5 +FGD,42.0,524,5 +FGD,44.0,540,5 +FGD,46.0,568,5 +FGD,48.0,594,5 +FGD,50.0,631,5 +FGD,52.0,667,5 +FGD,54.0,686,5 +FGD,56.0,715,5 +FGD,58.0,752,5 +FGD,60.0,780,5 +FGD,62.0,805,5 +FGD,64.0,823,5 +FGD,66.0,841,5 +FGD,68.0,859,5 +FGD,70.0,879,5 +FGD,72.0,909,5 +FGD,74.0,931,5 +FGD,76.0,961,5 +FGD,78.0,982,5 +FGD,80.0,1004,5 +FGD,82.0,1027,5 +FGD,84.0,1047,5 +FGD,86.0,1079,5 +FGD,88.0,1109,5 +FGD,90.0,1139,5 +FGD,92.0,1172,5 +FGD,94.0,1209,5 +FGD,96.0,1213,5 +FGD,98.0,1213,5 +FGD,100.0,1213,5 +FGD,102.0,1213,5 +FGD,104.0,1213,5 +FGD,106.0,1213,5 +FGD,108.0,1213,5 +FGD,110.0,1213,5 +FGD,112.0,1213,5 +FGD,114.0,1213,5 +FGD,116.0,1213,5 +FGD,118.0,1213,5 +FGD,120.0,1213,5 +FGD,2.0,55,6 +FGD,4.0,74,6 +FGD,6.0,93,6 +FGD,8.0,117,6 +FGD,10.0,139,6 +FGD,12.0,170,6 +FGD,14.0,192,6 +FGD,16.0,211,6 +FGD,18.0,240,6 +FGD,20.0,267,6 +FGD,22.0,291,6 +FGD,24.0,313,6 +FGD,26.0,337,6 +FGD,28.0,355,6 +FGD,30.0,373,6 +FGD,32.0,392,6 +FGD,34.0,424,6 +FGD,36.0,453,6 +FGD,38.0,481,6 +FGD,40.0,499,6 +FGD,42.0,524,6 +FGD,44.0,540,6 +FGD,46.0,567,6 +FGD,48.0,593,6 +FGD,50.0,629,6 +FGD,52.0,666,6 +FGD,54.0,686,6 +FGD,56.0,714,6 +FGD,58.0,751,6 +FGD,60.0,780,6 +FGD,62.0,805,6 +FGD,64.0,822,6 +FGD,66.0,839,6 +FGD,68.0,858,6 +FGD,70.0,876,6 +FGD,72.0,908,6 +FGD,74.0,930,6 +FGD,76.0,952,6 +FGD,78.0,980,6 +FGD,80.0,999,6 +FGD,82.0,1021,6 +FGD,84.0,1044,6 +FGD,86.0,1071,6 +FGD,88.0,1098,6 +FGD,90.0,1136,6 +FGD,92.0,1169,6 +FGD,94.0,1205,6 +FGD,96.0,1213,6 +FGD,98.0,1213,6 +FGD,100.0,1213,6 +FGD,102.0,1213,6 +FGD,104.0,1213,6 +FGD,106.0,1213,6 +FGD,108.0,1213,6 +FGD,110.0,1213,6 +FGD,112.0,1213,6 +FGD,114.0,1213,6 +FGD,116.0,1213,6 +FGD,118.0,1213,6 +FGD,120.0,1213,6 +FGD,2.0,56,7 +FGD,4.0,74,7 +FGD,6.0,94,7 +FGD,8.0,117,7 +FGD,10.0,138,7 +FGD,12.0,171,7 +FGD,14.0,192,7 +FGD,16.0,211,7 +FGD,18.0,241,7 +FGD,20.0,268,7 +FGD,22.0,291,7 +FGD,24.0,312,7 +FGD,26.0,338,7 +FGD,28.0,355,7 +FGD,30.0,374,7 +FGD,32.0,394,7 +FGD,34.0,424,7 +FGD,36.0,454,7 +FGD,38.0,481,7 +FGD,40.0,498,7 +FGD,42.0,522,7 +FGD,44.0,540,7 +FGD,46.0,566,7 +FGD,48.0,591,7 +FGD,50.0,626,7 +FGD,52.0,665,7 +FGD,54.0,682,7 +FGD,56.0,707,7 +FGD,58.0,749,7 +FGD,60.0,777,7 +FGD,62.0,804,7 +FGD,64.0,821,7 +FGD,66.0,839,7 +FGD,68.0,858,7 +FGD,70.0,876,7 +FGD,72.0,908,7 +FGD,74.0,929,7 +FGD,76.0,954,7 +FGD,78.0,981,7 +FGD,80.0,1003,7 +FGD,82.0,1027,7 +FGD,84.0,1047,7 +FGD,86.0,1078,7 +FGD,88.0,1104,7 +FGD,90.0,1138,7 +FGD,92.0,1171,7 +FGD,94.0,1206,7 +FGD,96.0,1213,7 +FGD,98.0,1213,7 +FGD,100.0,1213,7 +FGD,102.0,1213,7 +FGD,104.0,1213,7 +FGD,106.0,1213,7 +FGD,108.0,1213,7 +FGD,110.0,1213,7 +FGD,112.0,1213,7 +FGD,114.0,1213,7 +FGD,116.0,1213,7 +FGD,118.0,1213,7 +FGD,120.0,1213,7 +FGD,2.0,55,8 +FGD,4.0,73,8 +FGD,6.0,94,8 +FGD,8.0,118,8 +FGD,10.0,141,8 +FGD,12.0,174,8 +FGD,14.0,194,8 +FGD,16.0,213,8 +FGD,18.0,244,8 +FGD,20.0,270,8 +FGD,22.0,293,8 +FGD,24.0,313,8 +FGD,26.0,339,8 +FGD,28.0,357,8 +FGD,30.0,375,8 +FGD,32.0,398,8 +FGD,34.0,426,8 +FGD,36.0,457,8 +FGD,38.0,484,8 +FGD,40.0,503,8 +FGD,42.0,525,8 +FGD,44.0,543,8 +FGD,46.0,573,8 +FGD,48.0,596,8 +FGD,50.0,634,8 +FGD,52.0,670,8 +FGD,54.0,688,8 +FGD,56.0,720,8 +FGD,58.0,753,8 +FGD,60.0,781,8 +FGD,62.0,807,8 +FGD,64.0,825,8 +FGD,66.0,842,8 +FGD,68.0,862,8 +FGD,70.0,887,8 +FGD,72.0,912,8 +FGD,74.0,934,8 +FGD,76.0,964,8 +FGD,78.0,984,8 +FGD,80.0,1006,8 +FGD,82.0,1029,8 +FGD,84.0,1048,8 +FGD,86.0,1080,8 +FGD,88.0,1109,8 +FGD,90.0,1139,8 +FGD,92.0,1172,8 +FGD,94.0,1206,8 +FGD,96.0,1213,8 +FGD,98.0,1213,8 +FGD,100.0,1213,8 +FGD,102.0,1213,8 +FGD,104.0,1213,8 +FGD,106.0,1213,8 +FGD,108.0,1213,8 +FGD,110.0,1213,8 +FGD,112.0,1213,8 +FGD,114.0,1213,8 +FGD,116.0,1213,8 +FGD,118.0,1213,8 +FGD,120.0,1213,8 +FGD,2.0,56,9 +FGD,4.0,74,9 +FGD,6.0,95,9 +FGD,8.0,117,9 +FGD,10.0,138,9 +FGD,12.0,169,9 +FGD,14.0,191,9 +FGD,16.0,211,9 +FGD,18.0,242,9 +FGD,20.0,268,9 +FGD,22.0,291,9 +FGD,24.0,310,9 +FGD,26.0,334,9 +FGD,28.0,353,9 +FGD,30.0,373,9 +FGD,32.0,391,9 +FGD,34.0,421,9 +FGD,36.0,452,9 +FGD,38.0,481,9 +FGD,40.0,500,9 +FGD,42.0,522,9 +FGD,44.0,540,9 +FGD,46.0,566,9 +FGD,48.0,591,9 +FGD,50.0,630,9 +FGD,52.0,663,9 +FGD,54.0,685,9 +FGD,56.0,711,9 +FGD,58.0,751,9 +FGD,60.0,777,9 +FGD,62.0,805,9 +FGD,64.0,822,9 +FGD,66.0,840,9 +FGD,68.0,860,9 +FGD,70.0,884,9 +FGD,72.0,911,9 +FGD,74.0,933,9 +FGD,76.0,963,9 +FGD,78.0,983,9 +FGD,80.0,1004,9 +FGD,82.0,1027,9 +FGD,84.0,1048,9 +FGD,86.0,1078,9 +FGD,88.0,1101,9 +FGD,90.0,1137,9 +FGD,92.0,1170,9 +FGD,94.0,1205,9 +FGD,96.0,1213,9 +FGD,98.0,1213,9 +FGD,100.0,1213,9 +FGD,102.0,1213,9 +FGD,104.0,1213,9 +FGD,106.0,1213,9 +FGD,108.0,1213,9 +FGD,110.0,1213,9 +FGD,112.0,1213,9 +FGD,114.0,1213,9 +FGD,116.0,1213,9 +FGD,118.0,1213,9 +FGD,120.0,1213,9 diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/figure9c_failed.csv b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9c_failed.csv new file mode 100644 index 0000000..036a526 --- /dev/null +++ b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9c_failed.csv @@ -0,0 +1,234 @@ +scheduler,gpu_category,sum_gpu_demand,run +Random,8,100.0,0 +Random,1,358.0,0 +Random,<1,69.06000000000003,0 +Random,2,8.0,0 +Random,8,160.0,1 +Random,1,346.0,1 +Random,<1,48.2,1 +Random,2,2.0,1 +Random,8,180.0,2 +Random,1,350.0,2 +Random,2,2.0,2 +Random,<1,65.71000000000004,2 +Random,8,164.0,3 +Random,1,362.0,3 +Random,2,4.0,3 +Random,<1,55.22,3 +Random,8,132.0,4 +Random,1,329.0,4 +Random,<1,55.780000000000015,4 +Random,2,2.0,4 +Random,8,144.0,5 +Random,1,331.0,5 +Random,<1,87.71000000000011,5 +Random,8,160.0,6 +Random,1,333.0,6 +Random,2,4.0,6 +Random,<1,66.53000000000002,6 +Random,8,136.0,7 +Random,1,350.0,7 +Random,<1,63.989999999999974,7 +Random,2,2.0,7 +Random,8,192.0,8 +Random,2,2.0,8 +Random,1,322.0,8 +Random,<1,64.50000000000004,8 +Random,8,116.0,9 +Random,1,381.0,9 +Random,2,2.0,9 +Random,<1,60.920000000000044,9 +BestFit,<1,48.34,0 +BestFit,1,118.0,0 +BestFit,2,4.0,0 +BestFit,8,8.0,0 +BestFit,1,130.0,1 +BestFit,<1,43.599999999999994,1 +BestFit,2,2.0,1 +BestFit,8,12.0,1 +BestFit,1,122.0,2 +BestFit,<1,48.17,2 +BestFit,8,28.0,2 +BestFit,1,144.0,3 +BestFit,<1,52.82999999999999,3 +BestFit,8,16.0,3 +BestFit,8,12.0,4 +BestFit,<1,53.98000000000001,4 +BestFit,1,124.0,4 +BestFit,1,119.0,5 +BestFit,<1,54.61,5 +BestFit,8,16.0,5 +BestFit,1,105.0,6 +BestFit,<1,55.12000000000001,6 +BestFit,8,24.0,6 +BestFit,2,2.0,6 +BestFit,<1,60.389999999999986,7 +BestFit,1,128.0,7 +BestFit,8,4.0,7 +BestFit,1,106.0,8 +BestFit,<1,41.01,8 +BestFit,8,16.0,8 +BestFit,1,119.0,9 +BestFit,<1,54.46000000000002,9 +BestFit,8,12.0,9 +BestFit-PN,1,104.0,0 +BestFit-PN,<1,36.61999999999998,0 +BestFit-PN,2,4.0,0 +BestFit-PN,8,8.0,0 +BestFit-PN,1,90.0,1 +BestFit-PN,<1,32.76999999999999,1 +BestFit-PN,2,2.0,1 +BestFit-PN,8,12.0,1 +BestFit-PN,1,86.0,2 +BestFit-PN,<1,38.94999999999999,2 +BestFit-PN,8,28.0,2 +BestFit-PN,1,110.0,3 +BestFit-PN,<1,36.47999999999999,3 +BestFit-PN,8,16.0,3 +BestFit-PN,1,80.0,4 +BestFit-PN,<1,33.37999999999999,4 +BestFit-PN,8,8.0,4 +BestFit-PN,1,98.0,5 +BestFit-PN,<1,37.76999999999999,5 +BestFit-PN,8,16.0,5 +BestFit-PN,8,16.0,6 +BestFit-PN,<1,36.68999999999998,6 +BestFit-PN,1,73.0,6 +BestFit-PN,<1,52.00999999999998,7 +BestFit-PN,1,110.0,7 +BestFit-PN,8,4.0,7 +BestFit-PN,8,24.0,8 +BestFit-PN,1,78.0,8 +BestFit-PN,<1,32.97999999999998,8 +BestFit-PN,1,90.0,9 +BestFit-PN,<1,40.18,9 +BestFit-PN,8,12.0,9 +DotProd,1,267.0,0 +DotProd,<1,100.81000000000003,0 +DotProd,8,16.0,0 +DotProd,2,8.0,0 +DotProd,8,20.0,1 +DotProd,<1,100.92999999999998,1 +DotProd,1,259.0,1 +DotProd,2,2.0,1 +DotProd,<1,106.31000000000003,2 +DotProd,1,264.0,2 +DotProd,8,48.0,2 +DotProd,8,32.0,3 +DotProd,1,256.0,3 +DotProd,<1,104.03999999999998,3 +DotProd,2,4.0,3 +DotProd,<1,108.19999999999999,4 +DotProd,1,252.0,4 +DotProd,2,2.0,4 +DotProd,8,16.0,4 +DotProd,1,257.0,5 +DotProd,<1,122.51000000000009,5 +DotProd,8,24.0,5 +DotProd,1,228.0,6 +DotProd,<1,106.62000000000003,6 +DotProd,8,40.0,6 +DotProd,2,2.0,6 +DotProd,1,262.0,7 +DotProd,<1,117.63,7 +DotProd,8,16.0,7 +DotProd,2,4.0,7 +DotProd,<1,106.14000000000004,8 +DotProd,1,244.0,8 +DotProd,8,28.0,8 +DotProd,8,20.0,9 +DotProd,1,279.0,9 +DotProd,<1,111.64000000000006,9 +Packing,1,77.0,0 +Packing,<1,24.119999999999994,0 +Packing,2,4.0,0 +Packing,8,8.0,0 +Packing,<1,27.129999999999992,1 +Packing,1,66.0,1 +Packing,8,12.0,1 +Packing,<1,31.20999999999998,2 +Packing,1,57.0,2 +Packing,8,28.0,2 +Packing,1,79.0,3 +Packing,<1,25.649999999999995,3 +Packing,8,8.0,3 +Packing,1,67.0,4 +Packing,<1,26.869999999999994,4 +Packing,8,8.0,4 +Packing,1,58.0,5 +Packing,<1,26.04999999999999,5 +Packing,8,8.0,5 +Packing,1,68.0,6 +Packing,<1,34.27999999999998,6 +Packing,8,8.0,6 +Packing,1,77.0,7 +Packing,<1,33.329999999999984,7 +Packing,8,4.0,7 +Packing,1,58.0,8 +Packing,<1,25.86999999999999,8 +Packing,8,16.0,8 +Packing,1,61.0,9 +Packing,8,12.0,9 +Packing,<1,24.289999999999992,9 +Clustering,1,74.0,0 +Clustering,<1,23.789999999999996,0 +Clustering,2,4.0,0 +Clustering,8,8.0,0 +Clustering,1,63.0,1 +Clustering,<1,27.02999999999999,1 +Clustering,8,12.0,1 +Clustering,1,62.0,2 +Clustering,<1,33.03999999999998,2 +Clustering,8,28.0,2 +Clustering,1,82.0,3 +Clustering,<1,25.879999999999992,3 +Clustering,8,8.0,3 +Clustering,1,67.0,4 +Clustering,<1,26.869999999999994,4 +Clustering,8,8.0,4 +Clustering,1,61.0,5 +Clustering,<1,26.64999999999999,5 +Clustering,8,8.0,5 +Clustering,1,59.0,6 +Clustering,<1,32.329999999999984,6 +Clustering,8,8.0,6 +Clustering,1,77.0,7 +Clustering,<1,33.329999999999984,7 +Clustering,8,4.0,7 +Clustering,1,68.0,8 +Clustering,<1,28.299999999999986,8 +Clustering,8,16.0,8 +Clustering,1,63.0,9 +Clustering,8,12.0,9 +Clustering,<1,24.13999999999999,9 +FGD,1,50.0,0 +FGD,<1,15.470000000000008,0 +FGD,2,2.0,0 +FGD,8,8.0,0 +FGD,<1,13.240000000000006,1 +FGD,8,12.0,1 +FGD,1,28.0,1 +FGD,8,28.0,2 +FGD,1,15.0,2 +FGD,<1,9.010000000000003,2 +FGD,8,16.0,3 +FGD,1,64.0,3 +FGD,<1,20.71,3 +FGD,8,8.0,4 +FGD,1,26.0,4 +FGD,<1,9.700000000000001,4 +FGD,8,16.0,5 +FGD,1,36.0,5 +FGD,<1,13.140000000000004,5 +FGD,1,26.0,6 +FGD,<1,10.780000000000003,6 +FGD,8,8.0,6 +FGD,1,42.0,7 +FGD,<1,14.880000000000008,7 +FGD,8,4.0,7 +FGD,8,24.0,8 +FGD,1,31.0,8 +FGD,<1,8.860000000000003,8 +FGD,8,4.0,9 +FGD,1,34.0,9 +FGD,<1,11.690000000000005,9 diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/figure9d_breakdown.csv b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9d_breakdown.csv new file mode 100644 index 0000000..895f2ec --- /dev/null +++ b/standalone_fgd_replication/result/fig9-runs10-seed42/figure9d_breakdown.csv @@ -0,0 +1,211 @@ +scheduler,cause,pct,run +Random,deficient,35.7388063347044,0 +Random,stranded,50.84388925691453,0 +Random,non_gpu,13.417304408381078,0 +Random,deficient,34.73557582746495,1 +Random,stranded,51.84763177553633,1 +Random,non_gpu,13.416792396998733,1 +Random,deficient,32.23599762612463,2 +Random,stranded,54.34729419480967,2 +Random,non_gpu,13.416708179065703,2 +Random,deficient,35.22348736673766,3 +Random,stranded,51.36106798095887,3 +Random,non_gpu,13.415444652303465,3 +Random,deficient,37.28990897816531,4 +Random,stranded,49.297164239842466,4 +Random,non_gpu,13.412926781992226,4 +Random,deficient,33.061570632015744,5 +Random,stranded,53.52318453729513,5 +Random,non_gpu,13.415244830689124,5 +Random,deficient,32.76025205876825,6 +Random,stranded,53.82147627891412,6 +Random,non_gpu,13.418271662317641,6 +Random,deficient,35.91417938077978,7 +Random,stranded,50.671653042395334,7 +Random,non_gpu,13.41416757682489,7 +Random,deficient,33.42220124878191,8 +Random,stranded,53.156429482954216,8 +Random,non_gpu,13.42136926826388,8 +Random,deficient,34.16282286564735,9 +Random,stranded,52.42208671404028,9 +Random,non_gpu,13.415090420312373,9 +BestFit,deficient,60.13863729376035,0 +BestFit,stranded,26.465777451207234,0 +BestFit,non_gpu,13.395585255032419,0 +BestFit,deficient,62.52363314207797,1 +BestFit,stranded,24.084399214325146,1 +BestFit,non_gpu,13.39196764359688,1 +BestFit,deficient,60.27353301679447,2 +BestFit,stranded,26.332971554738183,2 +BestFit,non_gpu,13.393495428467356,2 +BestFit,deficient,60.53394493066288,3 +BestFit,stranded,26.07525652983309,3 +BestFit,non_gpu,13.39079853950404,3 +BestFit,deficient,58.1622251633782,4 +BestFit,stranded,28.447020484063167,4 +BestFit,non_gpu,13.39075435255864,4 +BestFit,deficient,61.630212182125085,5 +BestFit,stranded,24.980191572740235,5 +BestFit,non_gpu,13.389596245134683,5 +BestFit,deficient,60.87256195757875,6 +BestFit,stranded,25.7383405740182,6 +BestFit,non_gpu,13.389097468403058,6 +BestFit,deficient,59.12247940655183,7 +BestFit,stranded,27.488489147331034,7 +BestFit,non_gpu,13.389031446117135,7 +BestFit,deficient,66.89381077388964,8 +BestFit,stranded,19.714007541540678,8 +BestFit,non_gpu,13.39218168456969,8 +BestFit,deficient,62.99282063509818,9 +BestFit,stranded,23.61663277863407,9 +BestFit,non_gpu,13.390546586267751,9 +BestFit-PN,deficient,68.96826341069978,0 +BestFit-PN,stranded,17.647053302562007,0 +BestFit-PN,non_gpu,13.384683286738221,0 +BestFit-PN,deficient,68.04973123352077,1 +BestFit-PN,stranded,18.56597871020782,1 +BestFit-PN,non_gpu,13.384290056271414,1 +BestFit-PN,deficient,68.08860494342481,2 +BestFit-PN,stranded,18.53010183148674,2 +BestFit-PN,non_gpu,13.38129322508843,2 +BestFit-PN,deficient,67.48323066471876,3 +BestFit-PN,stranded,19.131600642154844,3 +BestFit-PN,non_gpu,13.385168693126396,3 +BestFit-PN,deficient,71.90718448844561,4 +BestFit-PN,stranded,14.713590408988916,4 +BestFit-PN,non_gpu,13.379225102565476,4 +BestFit-PN,deficient,70.96066153470433,5 +BestFit-PN,stranded,15.654898496776084,5 +BestFit-PN,non_gpu,13.384439968519581,5 +BestFit-PN,deficient,69.44952742985302,6 +BestFit-PN,stranded,17.164305212891808,6 +BestFit-PN,non_gpu,13.386167357255157,6 +BestFit-PN,deficient,65.02135548550643,7 +BestFit-PN,stranded,21.595632189871385,7 +BestFit-PN,non_gpu,13.383012324622179,7 +BestFit-PN,deficient,72.01882506602524,8 +BestFit-PN,stranded,14.595226850100154,8 +BestFit-PN,non_gpu,13.385948083874597,8 +BestFit-PN,deficient,70.04192070368347,9 +BestFit-PN,stranded,16.57539340370246,9 +BestFit-PN,non_gpu,13.382685892614063,9 +DotProd,deficient,38.01236736474552,0 +DotProd,stranded,48.58559889409166,0 +DotProd,non_gpu,13.402033741162834,0 +DotProd,deficient,41.896248037100605,1 +DotProd,stranded,44.70329001414907,1 +DotProd,non_gpu,13.400461948750314,1 +DotProd,deficient,38.741090913162495,2 +DotProd,stranded,47.85893308403287,2 +DotProd,non_gpu,13.399976002804612,2 +DotProd,deficient,42.17433863279165,3 +DotProd,stranded,44.426494509043984,3 +DotProd,non_gpu,13.399166858164369,3 +DotProd,deficient,40.27668154577081,4 +DotProd,stranded,46.324177358654886,4 +DotProd,non_gpu,13.399141095574313,4 +DotProd,deficient,38.402220701882364,5 +DotProd,stranded,48.19842349983156,5 +DotProd,non_gpu,13.399355798286072,5 +DotProd,deficient,40.45334505484374,6 +DotProd,stranded,46.1490201678109,6 +DotProd,non_gpu,13.397634777345363,6 +DotProd,deficient,38.58357528288748,7 +DotProd,stranded,48.01758334011993,7 +DotProd,non_gpu,13.398841376992603,7 +DotProd,deficient,42.467718391498316,8 +DotProd,stranded,44.12955705594475,8 +DotProd,non_gpu,13.402724552556942,8 +DotProd,deficient,40.73315665204993,9 +DotProd,stranded,45.86907274862853,9 +DotProd,non_gpu,13.397770599321538,9 +Packing,deficient,70.3733227347581,0 +Packing,stranded,16.226616657685575,0 +Packing,non_gpu,13.400060607556322,0 +Packing,deficient,72.31948360685789,1 +Packing,stranded,14.2826272478879,1 +Packing,non_gpu,13.397889145254208,1 +Packing,deficient,68.85465512591942,2 +Packing,stranded,17.736240747268276,2 +Packing,non_gpu,13.409104126812299,2 +Packing,deficient,75.36705288395626,3 +Packing,stranded,11.229013190166844,3 +Packing,non_gpu,13.403933925876874,3 +Packing,deficient,72.11037331565564,4 +Packing,stranded,14.478126334509422,4 +Packing,non_gpu,13.411500349834943,4 +Packing,deficient,74.44406963182671,5 +Packing,stranded,12.154103079902704,5 +Packing,non_gpu,13.401827288270582,5 +Packing,deficient,69.9216308242209,6 +Packing,stranded,16.678270437209846,6 +Packing,non_gpu,13.400098738569255,6 +Packing,deficient,71.25313614091225,7 +Packing,stranded,15.359155242432564,7 +Packing,non_gpu,13.387708616655198,7 +Packing,deficient,76.2638045832339,8 +Packing,stranded,10.334242328240505,8 +Packing,non_gpu,13.401953088525593,8 +Packing,deficient,73.95890617326477,9 +Packing,stranded,12.651342184913858,9 +Packing,non_gpu,13.38975164182136,9 +Clustering,deficient,71.2693275442415,0 +Clustering,stranded,15.286809523374439,0 +Clustering,non_gpu,13.443862932384052,0 +Clustering,deficient,72.84484896067954,1 +Clustering,stranded,13.710803357845592,1 +Clustering,non_gpu,13.444347681474856,1 +Clustering,deficient,68.04762741875561,2 +Clustering,stranded,18.51042681058752,2 +Clustering,non_gpu,13.441945770656858,2 +Clustering,deficient,74.20903149556159,3 +Clustering,stranded,12.344624188340838,3 +Clustering,non_gpu,13.446344316097553,3 +Clustering,deficient,72.45616163718674,4 +Clustering,stranded,14.098935295822312,4 +Clustering,non_gpu,13.44490306699096,4 +Clustering,deficient,73.53853608846572,5 +Clustering,stranded,13.018987452559049,5 +Clustering,non_gpu,13.442476458975234,5 +Clustering,deficient,72.9827611511483,6 +Clustering,stranded,13.576215760789692,6 +Clustering,non_gpu,13.44102308806201,6 +Clustering,deficient,72.39664577981543,7 +Clustering,stranded,14.164961657294278,7 +Clustering,non_gpu,13.438392562890295,7 +Clustering,deficient,74.0804214386662,8 +Clustering,stranded,12.475854307559816,8 +Clustering,non_gpu,13.443724253773977,8 +Clustering,deficient,75.19434578878081,9 +Clustering,stranded,11.362893406734855,9 +Clustering,non_gpu,13.44276080448433,9 +FGD,deficient,73.80818325564807,0 +FGD,stranded,12.750536263539015,0 +FGD,non_gpu,13.441280480812907,0 +FGD,deficient,77.54677581568315,1 +FGD,stranded,9.019598712646264,1 +FGD,non_gpu,13.433625471670585,1 +FGD,deficient,78.20770867047003,2 +FGD,stranded,8.360007170415006,2 +FGD,non_gpu,13.432284159114962,2 +FGD,deficient,72.4774276488274,3 +FGD,stranded,14.084583136593604,3 +FGD,non_gpu,13.437989214579,3 +FGD,deficient,81.46579687533068,4 +FGD,stranded,5.101515462320147,4 +FGD,non_gpu,13.432687662349185,4 +FGD,deficient,77.76699282565815,5 +FGD,stranded,8.802131653779115,5 +FGD,non_gpu,13.430875520562733,5 +FGD,deficient,79.26349076386757,6 +FGD,stranded,7.30273741423117,6 +FGD,non_gpu,13.433771821901283,6 +FGD,deficient,76.7636756175349,7 +FGD,stranded,9.80105743614767,7 +FGD,non_gpu,13.435266946317432,7 +FGD,deficient,78.2356765030782,8 +FGD,stranded,8.322733879342753,8 +FGD,non_gpu,13.441589617579067,8 +FGD,deficient,78.62410437939056,9 +FGD,stranded,7.935521321589273,9 +FGD,non_gpu,13.440374299020164,9 diff --git a/standalone_fgd_replication/result/fig9-runs10-seed42/paper-figure9.png b/standalone_fgd_replication/result/fig9-runs10-seed42/paper-figure9.png new file mode 100644 index 0000000..92219d6 Binary files /dev/null and b/standalone_fgd_replication/result/fig9-runs10-seed42/paper-figure9.png differ diff --git a/standalone_fgd_replication/schedulers.py b/standalone_fgd_replication/schedulers.py new file mode 100644 index 0000000..f171706 --- /dev/null +++ b/standalone_fgd_replication/schedulers.py @@ -0,0 +1,772 @@ +""" +Scheduling Policies for GPU Cluster Simulation + +Implements 6 scheduling policies from the FGD paper (Section 6.1): +1. Random - Random node selection +2. BestFit - Node with least remaining resources +3. DotProd - Smallest dot-product between remaining resources and task demands +4. Packing - Prioritize occupied GPUs, then idle GPUs on occupied nodes +5. Clustering - Pack tasks with same GPU request together +6. FGD - Fragmentation Gradient Descent +""" + +from abc import ABC, abstractmethod +from typing import List, Optional, Tuple +from collections import deque, Counter +import math +import random + +from simulator import Task, Node, Cluster, TaskDistribution + + +class Scheduler(ABC): + """Abstract base class for all scheduling policies""" + + def __init__(self, name: str): + self.name = name + + @abstractmethod + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + """ + Select a node for the given task. + + Args: + task: The task to schedule + cluster: Current cluster state + + Returns: + Node ID to schedule on, or None if no suitable node found + """ + pass + + def schedule(self, task: Task, cluster: Cluster) -> bool: + """ + Schedule a task on the cluster. + + Returns: + True if scheduled successfully, False otherwise + """ + node_id = self.select_node(task, cluster) + if node_id is not None: + return cluster.schedule_task(task, node_id) + return False + + +class RandomScheduler(Scheduler): + """ + Random-fit: Distributes tasks randomly to any node that meets requirements. + """ + + def __init__(self): + super().__init__("Random") + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + return random.choice(eligible).node_id + + +class BestFitScheduler(Scheduler): + """ + Best-fit: Assigns tasks to the node with the least remaining resources. + Score = 0.5 * free_cpu / MaxSpecCpu + 0.5 * free_gpu / MaxSpecGpu + matching the author's formula (best_fit_score.go), where MaxSpec values + are the global cluster-wide maximums computed once on first scheduling call. + """ + + def __init__(self): + super().__init__("BestFit") + self._max_cpu: Optional[float] = None + self._max_gpu: Optional[float] = None + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + # Compute global max specs once and cache (cluster topology is fixed) + if self._max_cpu is None: + self._max_cpu = max(n.total_cpu for n in cluster.nodes) + self._max_gpu = max(n.num_gpus for n in cluster.nodes) + + best_node = None + best_score = float('inf') + + for node in eligible: + cpu_score = 0.5 * node.remaining_cpu / self._max_cpu if self._max_cpu > 0 else 0 + gpu_score = 0.5 * node.total_unallocated_gpu / self._max_gpu if self._max_gpu > 0 else 0 + score = cpu_score + gpu_score + + if score < best_score: + best_score = score + best_node = node + + return best_node.node_id if best_node else None + + +class BestFitLocalScheduler(Scheduler): + """ + Best-fit with per-node normalization (original/naive implementation). + + Score = remaining_cpu / node.total_cpu + total_unallocated_gpu / node.num_gpus + + Kept for comparison against BestFitScheduler (global normalization). + Per-node normalization treats a 4-GPU node at 50% as equivalent to an + 8-GPU node at 50%, which is incorrect for heterogeneous clusters. + """ + + def __init__(self): + super().__init__("BestFit-PN") + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + best_node = None + best_score = float('inf') + + for node in eligible: + cpu_score = node.remaining_cpu / node.total_cpu if node.total_cpu > 0 else 0 + gpu_score = node.total_unallocated_gpu / node.num_gpus if node.num_gpus > 0 else 0 + score = cpu_score + gpu_score + + if score < best_score: + best_score = score + best_node = node + + return best_node.node_id if best_node else None + + +class DotProdScheduler(Scheduler): + """ + Dot-product: Allocates to node with smallest dot-product between + remaining resources and task demands. + """ + + def __init__(self): + super().__init__("DotProd") + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + best_node = None + best_score = float('inf') + + # Normalize demands + max_cpu = max(n.total_cpu for n in cluster.nodes) + max_gpu = max(n.num_gpus for n in cluster.nodes) + + task_cpu_norm = task.cpu_demand / max_cpu if max_cpu > 0 else 0 + task_gpu_norm = task.gpu_demand / max_gpu if max_gpu > 0 else 0 + + for node in eligible: + # Normalize remaining resources + cpu_norm = node.remaining_cpu / max_cpu if max_cpu > 0 else 0 + gpu_norm = node.total_unallocated_gpu / max_gpu if max_gpu > 0 else 0 + + # Dot product + score = cpu_norm * task_cpu_norm + gpu_norm * task_gpu_norm + + if score < best_score: + best_score = score + best_node = node + + return best_node.node_id if best_node else None + + +class PackingScheduler(Scheduler): + """ + GPU Packing: Prioritizes task assignment to: + 1. Occupied GPUs (partial GPUs on nodes with some allocation) + 2. Idle GPUs on occupied nodes + 3. Fully idle nodes + + The intuition is to reserve available resources for multi-GPU tasks. + """ + + def __init__(self): + super().__init__("Packing") + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + # Categorize nodes + occupied_partial = [] # Nodes with partial GPUs + occupied_full = [] # Occupied nodes with only full GPUs available + idle = [] # Fully idle nodes + + for node in eligible: + has_partial = any(0 < g < 1.0 for g in node.gpu_remaining) + is_occupied = node.allocated_cpu > 0 or any(g < 1.0 for g in node.gpu_remaining) + + if has_partial: + occupied_partial.append(node) + elif is_occupied: + occupied_full.append(node) + else: + idle.append(node) + + # Priority: occupied with partial GPUs > occupied > idle + # Within each category, prefer node with less remaining (pack tighter) + def sort_key(n): + return n.total_unallocated_gpu + + if occupied_partial: + occupied_partial.sort(key=sort_key) + return occupied_partial[0].node_id + elif occupied_full: + occupied_full.sort(key=sort_key) + return occupied_full[0].node_id + elif idle: + idle.sort(key=sort_key) + return idle[0].node_id + + return None + + +class ClusteringScheduler(Scheduler): + """ + GPU Clustering: Packs tasks requesting the same GPU amount together. + Avoids heterogeneous distribution of task resource requirements on the same node. + """ + + def __init__(self): + super().__init__("Clustering") + # Track which nodes have which GPU request patterns + self.node_gpu_patterns: dict = {} # node_id -> set of gpu_demands seen + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + # Categorize: nodes that already have this GPU pattern vs others + matching_nodes = [] + other_nodes = [] + + for node in eligible: + if node.node_id in self.node_gpu_patterns: + patterns = self.node_gpu_patterns[node.node_id] + if task.gpu_demand in patterns: + matching_nodes.append(node) + else: + other_nodes.append(node) + else: + other_nodes.append(node) + + # Prefer nodes with matching patterns, then others + # Within each group, use best-fit (least remaining resources) + def sort_key(n): + return n.total_unallocated_gpu + + if matching_nodes: + matching_nodes.sort(key=sort_key) + selected = matching_nodes[0] + elif other_nodes: + other_nodes.sort(key=sort_key) + selected = other_nodes[0] + else: + return None + + # Update pattern tracking + if selected.node_id not in self.node_gpu_patterns: + self.node_gpu_patterns[selected.node_id] = set() + self.node_gpu_patterns[selected.node_id].add(task.gpu_demand) + + return selected.node_id + + def reset(self): + """Reset pattern tracking for new simulation""" + self.node_gpu_patterns = {} + + +class FGDScheduler(Scheduler): + """ + Fragmentation Gradient Descent (FGD): + Schedules tasks towards the steepest descent of fragmentation. + + For each task, evaluates all nodes and selects the one that + causes the minimum increase in fragmentation. + + Algorithm 1 from the paper. + """ + + def __init__(self, num_workers: int = None, scheduling_task_types=None): + super().__init__("FGD") + self.num_workers = num_workers + self._pool = None + # If set, use this for scheduling decisions instead of cluster's distribution + self.scheduling_task_types = scheduling_task_types + # If set, use GPU-type-aware distribution: [((cpu, gpu, gpu_spec), popularity)] + self.typed_task_types = None + # GPU slot index chosen by select_node for the upcoming schedule() call. + # Valid only for partial GPU tasks; -1 means use default allocate_task(). + self._pending_slot: int = -1 + + @staticmethod + def _compute_frag_delta_for_node(args: Tuple) -> Tuple[int, float, int]: + """ + Worker function to compute fragmentation delta for a single node. + Used for parallel evaluation. + + Args: + args: (node_id, remaining_cpu, gpu_remaining, num_gpus, total_cpu, + task_cpu, task_gpu, task_types, node_gpu_model) + task_types entries may be ((cpu, gpu), popularity) or + ((cpu, gpu, gpu_spec), popularity) — the latter enables + GPU-type-aware fragmentation computation. + + Returns: + (node_id, fragmentation_delta) + """ + (node_id, remaining_cpu, gpu_remaining, num_gpus, total_cpu, + task_cpu, task_gpu, task_types, node_gpu_model) = args + + # Reconstruct node state + node = Node( + node_id=node_id, + total_cpu=total_cpu, + num_gpus=num_gpus, + allocated_cpu=total_cpu - remaining_cpu, + gpu_remaining=list(gpu_remaining) + ) + + task = Task(task_id=-1, cpu_demand=task_cpu, gpu_demand=task_gpu) + + def _frag_for_types(node_state): + frag = 0.0 + for type_key, popularity in task_types: + cpu, gpu = type_key[0], type_key[1] + gpu_spec = type_key[2] if len(type_key) > 2 else '' + # GPU type compatibility: if task requires a specific type and + # this node's GPU model is incompatible, all unallocated GPUs + # on this node are fragmented from that task's perspective. + if gpu_spec and node_gpu_model: + allowed = set(gpu_spec.split('|')) + if node_gpu_model not in allowed: + frag += popularity * node_state.total_unallocated_gpu + continue + dummy = Task(task_id=-1, cpu_demand=cpu, gpu_demand=gpu) + frag += popularity * node_state.get_fragmentation_for_task(dummy) + return frag + + # Compute fragmentation before (only for this node) + frag_before = _frag_for_types(node) + + if task.is_partial_gpu(): + # For partial GPU tasks, evaluate each eligible GPU slot separately + # and track which slot produces the minimum fragmentation delta. + # The slot index is returned so FGD can place the task on the same + # slot that was evaluated, keeping scoring and placement consistent. + best_delta = float('inf') + best_slot = -1 + node.allocated_cpu += task_cpu # CPU is always consumed + for i in range(num_gpus): + if gpu_remaining[i] >= task_gpu: + node.gpu_remaining = list(gpu_remaining) + node.gpu_remaining[i] -= task_gpu + delta = _frag_for_types(node) - frag_before + if delta < best_delta: + best_delta = delta + best_slot = i + return (node_id, best_delta, best_slot) + else: + # Full-GPU and no-GPU tasks have a single allocation path + node.allocate_task(task) + frag_after = _frag_for_types(node) + return (node_id, frag_after - frag_before, -1) + + def _get_pool(self): + """Lazy initialization of process pool""" + if self._pool is None: + from multiprocessing import Pool, cpu_count + workers = self.num_workers or cpu_count() + self._pool = Pool(workers) + return self._pool + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + # Priority: typed (GPU-type-aware) > explicit override > cluster distribution + if self.typed_task_types is not None: + task_types = self.typed_task_types + elif self.scheduling_task_types is not None: + task_types = self.scheduling_task_types + else: + task_types = cluster.task_distribution.get_task_types() + + # Prepare arguments for parallel workers + args_list = [ + ( + node.node_id, + node.remaining_cpu, + tuple(node.gpu_remaining), + node.num_gpus, + node.total_cpu, + task.cpu_demand, + task.gpu_demand, + task_types, + node.gpu_model, + ) + for node in eligible + ] + + # Parallel execution + pool = self._get_pool() + results = pool.map(FGDScheduler._compute_frag_delta_for_node, args_list) + + # Paper scores: int(sigmoid(-delta) * 100), higher = better. + best_node_id = None + best_score = -1 + self._pending_slot = -1 + for node_id, delta, slot in results: + score = int(100.0 / (1.0 + math.exp(delta))) # sigmoid(-delta)*100 + if score > best_score: + best_score = score + best_node_id = node_id + self._pending_slot = slot + + return best_node_id + + def schedule(self, task: Task, cluster: Cluster) -> bool: + """ + Override base schedule() to place partial GPU tasks on the exact slot + that was scored in select_node(), not the best-fit slot from allocate_task(). + This ensures scoring and placement are consistent. + """ + node_id = self.select_node(task, cluster) + if node_id is None: + return False + + if task.is_partial_gpu() and self._pending_slot >= 0: + node = cluster.nodes[node_id] + if node.allocate_to_slot(task, self._pending_slot): + cluster.scheduled_tasks.append((task, node_id)) + return True + return False + else: + return cluster.schedule_task(task, node_id) + + def cleanup(self): + """Clean up the process pool""" + if self._pool is not None: + self._pool.close() + self._pool.join() + self._pool = None + + +class WindowedFGDScheduler(FGDScheduler): + """ + Distribution-shift-aware FGD using a sliding window. + + Instead of using the global task distribution (which assumes perfect + future knowledge), this variant estimates the distribution online + from the last `window_size` tasks observed. + + This addresses FGD's key assumption: that the task popularity + distribution is known in advance. In production, distributions + shift over time, so a sliding window provides a more realistic + and adaptive estimate. + """ + + def __init__(self, window_size: int = 500, num_workers: int = None): + super().__init__(num_workers=num_workers) + self.name = f"W-FGD-{window_size}" + self.window_size = window_size + self._window: deque = deque(maxlen=window_size) + self._cached_task_types = None + self._cache_dirty = True + + def observe_task(self, task: Task): + """Record a task into the sliding window""" + gpu_rounded = round(task.gpu_demand, 2) + cpu_bucket = round(task.cpu_demand / 4) * 4 + self._window.append((cpu_bucket, gpu_rounded)) + self._cache_dirty = True + + def _get_windowed_task_types(self) -> List[Tuple[Tuple[float, float], float]]: + """Compute task distribution from the sliding window""" + if not self._cache_dirty and self._cached_task_types is not None: + return self._cached_task_types + + if not self._window: + return [] + + counts = Counter(self._window) + total = sum(counts.values()) + self._cached_task_types = [ + ((cpu, gpu), count / total) for (cpu, gpu), count in counts.items() + ] + self._cache_dirty = False + return self._cached_task_types + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + # Use windowed distribution instead of global + task_types = self._get_windowed_task_types() + + # Fall back to global distribution if window is empty + if not task_types: + if cluster.task_distribution is not None: + task_types = cluster.task_distribution.get_task_types() + else: + return BestFitScheduler().select_node(task, cluster) + + # Prepare arguments for parallel workers + args_list = [ + ( + node.node_id, + node.remaining_cpu, + tuple(node.gpu_remaining), + node.num_gpus, + node.total_cpu, + task.cpu_demand, + task.gpu_demand, + task_types, + node.gpu_model, + ) + for node in eligible + ] + + # Parallel execution + pool = self._get_pool() + results = pool.map(FGDScheduler._compute_frag_delta_for_node, args_list) + + best_node_id = None + best_score = -1 + self._pending_slot = -1 + for node_id, delta, slot in results: + score = int(100.0 / (1.0 + math.exp(delta))) + if score > best_score: + best_score = score + best_node_id = node_id + self._pending_slot = slot + + return best_node_id + + def reset(self): + """Reset the sliding window""" + self._window.clear() + self._cached_task_types = None + self._cache_dirty = True + + +class BayesianFGDScheduler(FGDScheduler): + """ + Bayesian FGD: Starts with a uniform prior over a (cpu, gpu) grid derived + from cluster specs, then performs Bayesian updates as tasks arrive. + + Grid: CPU bucketed by 4 ({0, 4, 8, ..., max_cpu}), + GPU bucketed by 0.1 ({0.0, 0.1, 0.2, ..., max_gpu}). + Prior: uniform weight across all grid cells, total = prior_strength. + Update: each observed task adds 1 count to its bucket. + + Equivalent to Dirichlet-Multinomial posterior: + p_m = (prior_count_m + observed_count_m) / total_count + """ + + def __init__(self, prior_strength: float = 10.0, min_gpu_tasks: int = 50, + num_workers: int = None): + super().__init__(num_workers=num_workers) + self.name = "B-FGD" + self.prior_strength = prior_strength + self.min_gpu_tasks = min_gpu_tasks # Use Packing until this many GPU tasks observed + self._type_counts: Counter = Counter() + self._total_count: float = 0.0 + self._gpu_task_count: int = 0 # Number of GPU-demanding tasks observed + self._cached_task_types = None + self._cache_dirty = True + self._fallback = PackingScheduler() + + def set_uniform_prior(self, max_cpu: int, max_gpu: int): + """Initialize uniform prior over (cpu, gpu) grid from cluster specs. + + Grid: cpu in {0, 4, 8, ..., max_cpu} + gpu in {0.0, 0.1, 0.2, ..., 1.0, 2.0, 3.0, ..., max_gpu} + Each cell gets equal weight, total pseudo-counts = prior_strength. + """ + self._type_counts.clear() + max_cpu = int(max_cpu) + max_gpu = int(max_gpu) + cpu_values = list(range(0, max_cpu + 1, 4)) + # GPU: 0.0-1.0 by 0.1, then 2.0-max_gpu by 1.0 + gpu_values = [round(i * 0.1, 1) for i in range(11)] # 0.0..1.0 + gpu_values += list(range(2, max_gpu + 1)) # 2, 3, ..., max_gpu + + n_types = len(cpu_values) * len(gpu_values) + weight_per_type = self.prior_strength / n_types + + for cpu in cpu_values: + for gpu in gpu_values: + self._type_counts[(cpu, gpu)] = weight_per_type + + self._total_count = self.prior_strength + self._cache_dirty = True + print(f" B-FGD uniform prior: {len(cpu_values)} CPU x {len(gpu_values)} GPU = " + f"{n_types} types, prior_strength={self.prior_strength}, " + f"weight/type={weight_per_type:.6f}") + + def observe_task(self, task: Task): + """Bayesian update: bucket task by cpu/4 and gpu (0.1 for <1, 1.0 for >=1).""" + if task.gpu_demand >= 1.0: + gpu_bucketed = round(task.gpu_demand) + else: + gpu_bucketed = round(round(task.gpu_demand / 0.1) * 0.1, 1) + cpu_bucket = round(task.cpu_demand / 4) * 4 + self._type_counts[(cpu_bucket, gpu_bucketed)] += 1 + self._total_count += 1 + if task.gpu_demand > 0: + self._gpu_task_count += 1 + self._cache_dirty = True + + def _get_bayesian_task_types(self) -> List[Tuple[Tuple[float, float], float]]: + """Compute task distribution from accumulated counts.""" + if not self._cache_dirty and self._cached_task_types is not None: + return self._cached_task_types + + if self._total_count == 0: + return [] + + self._cached_task_types = [ + ((cpu, gpu), count / self._total_count) + for (cpu, gpu), count in self._type_counts.items() + ] + self._cache_dirty = False + return self._cached_task_types + + def select_node(self, task: Task, cluster: Cluster) -> Optional[int]: + # Fall back to Packing until enough GPU tasks observed + if self._gpu_task_count < self.min_gpu_tasks: + return self._fallback.select_node(task, cluster) + + eligible = cluster.get_eligible_nodes(task) + if not eligible: + return None + + task_types = self._get_bayesian_task_types() + + if not task_types: + return self._fallback.select_node(task, cluster) + + args_list = [ + ( + node.node_id, node.remaining_cpu, + tuple(node.gpu_remaining), node.num_gpus, node.total_cpu, + task.cpu_demand, task.gpu_demand, task_types, + node.gpu_model, + ) + for node in eligible + ] + + pool = self._get_pool() + results = pool.map(FGDScheduler._compute_frag_delta_for_node, args_list) + + best_node_id = None + best_score = -1 + self._pending_slot = -1 + for node_id, delta, slot in results: + score = int(100.0 / (1.0 + math.exp(delta))) + if score > best_score: + best_score = score + best_node_id = node_id + self._pending_slot = slot + + return best_node_id + + def reset(self): + """Reset all counts and cache.""" + self._type_counts.clear() + self._total_count = 0.0 + self._gpu_task_count = 0 + self._cached_task_types = None + self._cache_dirty = True + + +def get_scheduler(name: str) -> Scheduler: + """Factory function to get scheduler by name""" + schedulers = { + 'random': RandomScheduler, + 'bestfit': BestFitScheduler, + 'bestfit-pn': BestFitLocalScheduler, + 'dotprod': DotProdScheduler, + 'packing': PackingScheduler, + 'clustering': ClusteringScheduler, + 'fgd': FGDScheduler, + } + + name_lower = name.lower() + if name_lower not in schedulers: + raise ValueError(f"Unknown scheduler: {name}. Available: {list(schedulers.keys())}") + + return schedulers[name_lower]() + + +def get_all_schedulers() -> List[Scheduler]: + """Return instances of all schedulers (global-norm BestFit only).""" + return [ + RandomScheduler(), + BestFitScheduler(), + DotProdScheduler(), + PackingScheduler(), + ClusteringScheduler(), + FGDScheduler(), + ] + + +def get_all_schedulers_with_bestfit_variants() -> List[Scheduler]: + """Return all schedulers including both BestFit normalization variants. + Used by exp_fig11_14 to compare per-node vs global normalization. + """ + return [ + RandomScheduler(), + BestFitScheduler(), + BestFitLocalScheduler(), + DotProdScheduler(), + PackingScheduler(), + ClusteringScheduler(), + FGDScheduler(), + ] + + +if __name__ == "__main__": + from simulator import Cluster, Task, create_alibaba_like_distribution + + print("=== Scheduler Test ===\n") + + # Create test tasks + tasks = [ + Task(task_id=i, cpu_demand=8, gpu_demand=1.0) for i in range(5) + ] + [ + Task(task_id=i+5, cpu_demand=4, gpu_demand=0.5) for i in range(5) + ] + + # Test each scheduler + for scheduler in get_all_schedulers(): + # Fresh cluster for each scheduler + cluster = Cluster() + cluster.create_homogeneous_cluster(num_nodes=4, cpu_per_node=64, gpus_per_node=4) + cluster.set_task_distribution(create_alibaba_like_distribution()) + + # Reset clustering scheduler's state + if isinstance(scheduler, ClusteringScheduler): + scheduler.reset() + + scheduled = 0 + for task in tasks: + if scheduler.schedule(task, cluster): + scheduled += 1 + + print(f"{scheduler.name:12} - Scheduled: {scheduled}/{len(tasks)}, " + f"Frag Rate: {cluster.compute_fragmentation_rate():.2f}%, " + f"GPU Alloc: {cluster.gpu_allocation_rate:.2f}%") diff --git a/standalone_fgd_replication/simulator.py b/standalone_fgd_replication/simulator.py new file mode 100644 index 0000000..8d6a3e0 --- /dev/null +++ b/standalone_fgd_replication/simulator.py @@ -0,0 +1,436 @@ +""" +Lightweight GPU Cluster Simulator for FGD Replication + +Based on: "Beware of Fragmentation: Scheduling GPU-Sharing Workloads +with Fragmentation Gradient Descent" (ATC'23) +""" + +from dataclasses import dataclass, field +from typing import List, Dict, Optional, Tuple +import copy + + +@dataclass +class Task: + """ + Represents a task/pod requesting resources. + + Attributes: + task_id: Unique identifier + cpu_demand: Number of CPUs requested (in cores) + gpu_demand: GPU request - either partial (0,1) or full integer + e.g., 0.3 GPUs, 1 GPU, 2 GPUs + name: Task name from trace (optional) + creation_time: Timestamp of creation in seconds (optional) + scheduled_time: Timestamp of scheduling in seconds (optional) + deletion_time: Timestamp of deletion in seconds (optional) + gpu_spec: GPU type constraint from trace (optional) + """ + task_id: int + cpu_demand: float + gpu_demand: float + name: str = "" + creation_time: int = 0 + scheduled_time: int = 0 + deletion_time: int = 0 + gpu_spec: str = "" + + def is_partial_gpu(self) -> bool: + """Check if task requests partial GPU (0 < demand < 1)""" + return 0 < self.gpu_demand < 1 + + def is_full_gpu(self) -> bool: + """Check if task requests one or more full GPUs""" + return self.gpu_demand >= 1 and self.gpu_demand == int(self.gpu_demand) + + def is_no_gpu(self) -> bool: + """Check if task requests no GPU""" + return self.gpu_demand == 0 + + +@dataclass +class Node: + """ + Represents a node in the cluster with CPU and multiple GPUs. + + Each GPU tracks its remaining capacity independently (0 to 1). + GPU sharing allows multiple tasks on the same GPU if capacity permits. + + Attributes: + node_id: Unique identifier + total_cpu: Total CPU cores on the node + num_gpus: Number of GPUs on the node + allocated_cpu: Currently allocated CPU + gpu_remaining: List of remaining capacity for each GPU [0,1] + name: Node name from trace (optional) + gpu_model: GPU type from trace (optional) + memory_mib: Memory capacity in MiB from trace (optional) + """ + node_id: int + total_cpu: float + num_gpus: int + allocated_cpu: float = 0.0 + gpu_remaining: List[float] = field(default_factory=list) + name: str = "" + gpu_model: str = "" + memory_mib: int = 0 + + def __post_init__(self): + if not self.gpu_remaining: + # Initialize all GPUs as fully available (1.0 each) + self.gpu_remaining = [1.0] * self.num_gpus + + @property + def remaining_cpu(self) -> float: + """Available CPU on the node""" + return self.total_cpu - self.allocated_cpu + + @property + def fully_unallocated_gpus(self) -> int: + """Count of GPUs with 100% capacity remaining (f in paper)""" + return sum(1 for g in self.gpu_remaining if g == 1.0) + + @property + def max_partial_gpu(self) -> float: + """Maximum remaining capacity among partial GPUs (p in paper)""" + partial = [g for g in self.gpu_remaining if 0 < g < 1.0] + return max(partial) if partial else 0.0 + + @property + def scalar_gpu_capacity(self) -> float: + """ + Scalar representation of unallocated GPU capacity: u = f + p + (Equation from Section 3.1) + """ + return self.fully_unallocated_gpus + self.max_partial_gpu + + @property + def total_unallocated_gpu(self) -> float: + """Sum of all remaining GPU capacity""" + return sum(self.gpu_remaining) + + def can_fit_task(self, task: Task) -> bool: + """Check if node has sufficient resources for the task""" + # Check CPU + if self.remaining_cpu < task.cpu_demand: + return False + + # Check GPU-type compatibility (paper behavior): + # - Empty task gpu_spec means no type constraint. + # - Non-empty gpu_spec requires this node's gpu_model to match one of + # the '|' separated allowed types. + if not self._is_gpu_type_compatible(task): + return False + + # Check GPU + if task.is_no_gpu(): + return True + + if task.is_partial_gpu(): + # Need at least one GPU with enough remaining capacity + return any(g >= task.gpu_demand for g in self.gpu_remaining) + + if task.is_full_gpu(): + # Need enough fully unallocated GPUs + return self.fully_unallocated_gpus >= int(task.gpu_demand) + + return False + + def _is_gpu_type_compatible(self, task: Task) -> bool: + """Return whether this node can host task's gpu_spec constraint.""" + pod_gpu_type = (task.gpu_spec or "").strip() + if pod_gpu_type == "": + return True + + node_gpu_type = (self.gpu_model or "").strip() + if node_gpu_type == "": + return False + + requested_types = [t.strip() for t in pod_gpu_type.split("|") if t.strip()] + if not requested_types: + return True + return node_gpu_type in requested_types + + def allocate_task(self, task: Task) -> bool: + """ + Allocate resources to a task. Returns True if successful. + For partial GPU tasks, assigns to GPU with least remaining capacity + that can still fit the task (best-fit within node). + """ + if not self.can_fit_task(task): + return False + + # Allocate CPU + self.allocated_cpu += task.cpu_demand + + # Allocate GPU + if task.is_no_gpu(): + return True + + if task.is_partial_gpu(): + # Find GPU with minimum remaining capacity that can fit + best_idx = -1 + best_remaining = float('inf') + for i, g in enumerate(self.gpu_remaining): + if g >= task.gpu_demand and g < best_remaining: + best_remaining = g + best_idx = i + if best_idx >= 0: + self.gpu_remaining[best_idx] -= task.gpu_demand + return True + + if task.is_full_gpu(): + # Allocate from fully unallocated GPUs + gpus_needed = int(task.gpu_demand) + allocated = 0 + for i in range(len(self.gpu_remaining)): + if self.gpu_remaining[i] == 1.0 and allocated < gpus_needed: + self.gpu_remaining[i] = 0.0 + allocated += 1 + return True + + return False + + def allocate_to_slot(self, task: Task, slot_idx: int) -> bool: + """ + Allocate a partial GPU task to a specific GPU slot, bypassing best-fit + selection. Used by FGD to place the task on the exact slot that was + evaluated during node scoring, keeping scoring and placement consistent. + """ + if self.remaining_cpu < task.cpu_demand: + return False + if slot_idx < 0 or slot_idx >= len(self.gpu_remaining): + return False + if self.gpu_remaining[slot_idx] < task.gpu_demand: + return False + self.allocated_cpu += task.cpu_demand + self.gpu_remaining[slot_idx] -= task.gpu_demand + return True + + def get_fragmentation_for_task(self, task: Task) -> float: + """ + Calculate F_n(m): fragmented GPUs on this node for a specific task. + (Section 3.2, Equations 2-3) + + Returns the amount of GPU resources that cannot be allocated to the task. + """ + # Case 3: Task requests no GPU - all unallocated GPUs are fragments + if task.is_no_gpu(): + return self.total_unallocated_gpu + + # Case 1: Task cannot run due to insufficient CPU or GPU + if self.remaining_cpu < task.cpu_demand or self.scalar_gpu_capacity < task.gpu_demand: + return self.total_unallocated_gpu + + # Case 2 (Q-III): Check each GPU + # GPUs with insufficient capacity are considered fragmented + # Count fragmented capacity: GPUs that can't fit this task + fragmented = 0.0 + gpu_demand = min(task.gpu_demand, 1) + for g in self.gpu_remaining: + if g < gpu_demand: + # This GPU cannot fit the task - its remaining capacity is fragmented + fragmented += g + return fragmented + +@dataclass +class TaskDistribution: + """ + Represents the target workload distribution M. + Maps task types to their popularity (probability). + + Task types are defined by (cpu_demand, gpu_demand) tuples. + """ + # Dict mapping (cpu_demand, gpu_demand) -> popularity + distribution: Dict[Tuple[float, float], float] = field(default_factory=dict) + + def add_task_type(self, cpu_demand: float, gpu_demand: float, popularity: float): + """Add a task type with its popularity""" + self.distribution[(cpu_demand, gpu_demand)] = popularity + + def normalize(self): + """Normalize popularities to sum to 1""" + total = sum(self.distribution.values()) + if total > 0: + for key in self.distribution: + self.distribution[key] /= total + + def get_task_types(self) -> List[Tuple[Tuple[float, float], float]]: + """Return list of ((cpu, gpu), popularity) tuples""" + return list(self.distribution.items()) + + +class Cluster: + """ + Represents a GPU cluster with multiple nodes. + + Attributes: + nodes: List of nodes in the cluster + task_distribution: Target workload distribution for fragmentation calculation + """ + + def __init__(self): + self.nodes: List[Node] = [] + self.task_distribution: Optional[TaskDistribution] = None + self.scheduled_tasks: List[Tuple[Task, int]] = [] # (task, node_id) + + def add_node(self, node: Node): + """Add a node to the cluster""" + self.nodes.append(node) + + def create_homogeneous_cluster(self, num_nodes: int, cpu_per_node: float, + gpus_per_node: int): + """Create a cluster with identical nodes""" + self.nodes = [] + for i in range(num_nodes): + self.nodes.append(Node( + node_id=i, + total_cpu=cpu_per_node, + num_gpus=gpus_per_node + )) + + def set_task_distribution(self, distribution: TaskDistribution): + """Set the target workload distribution""" + self.task_distribution = distribution + + @property + def total_gpu_capacity(self) -> int: + """Total number of GPUs in the cluster""" + return sum(n.num_gpus for n in self.nodes) + + @property + def total_cpu_capacity(self) -> float: + """Total CPU cores in the cluster""" + return sum(n.total_cpu for n in self.nodes) + + @property + def total_unallocated_gpu(self) -> float: + """Total unallocated GPU capacity in the cluster""" + return sum(n.total_unallocated_gpu for n in self.nodes) + + @property + def total_allocated_gpu(self) -> float: + """Total allocated GPU capacity""" + return self.total_gpu_capacity - self.total_unallocated_gpu + + @property + def gpu_allocation_rate(self) -> float: + """Percentage of GPU capacity allocated""" + if self.total_gpu_capacity == 0: + return 0.0 + return (self.total_allocated_gpu / self.total_gpu_capacity) * 100 + + def get_eligible_nodes(self, task: Task) -> List[Node]: + """Get all nodes that can fit the task""" + return [n for n in self.nodes if n.can_fit_task(task)] + + def compute_node_fragmentation(self, node: Node) -> float: + """ + Compute F_n(M): fragmentation on node n for the entire workload M. + (Equation 1) + + F_n(M) = sum over m in M of: p_m * F_n(m) + """ + if self.task_distribution is None: + return 0.0 + + fragmentation = 0.0 + for (cpu, gpu), popularity in self.task_distribution.get_task_types(): + dummy_task = Task(task_id=-1, cpu_demand=cpu, gpu_demand=gpu) + fragmentation += popularity * node.get_fragmentation_for_task(dummy_task) + + return fragmentation + + def compute_cluster_fragmentation(self) -> float: + """ + Compute F_N(M): total fragmentation across all nodes. + (Equation 5) + """ + return sum(self.compute_node_fragmentation(n) for n in self.nodes) + + def compute_fragmentation_rate(self) -> float: + """ + Compute f_N(M): fragmentation rate (percentage). + (Equation 6) + + f_N(M) = F_N(M) / total_unallocated_gpu * 100 + """ + total_unallocated = self.total_unallocated_gpu + if total_unallocated == 0: + return 100.0 # All GPUs allocated means 100% of remaining (0) is fragmented + + return (self.compute_cluster_fragmentation() / total_unallocated) * 100 + + def deep_copy(self) -> 'Cluster': + """Create a deep copy of the cluster state""" + return copy.deepcopy(self) + + def schedule_task(self, task: Task, node_id: int) -> bool: + """Schedule a task on a specific node""" + node = self.nodes[node_id] + if node.allocate_task(task): + self.scheduled_tasks.append((task, node_id)) + return True + return False + + +def create_alibaba_like_distribution() -> TaskDistribution: + """ + Create a task distribution similar to Alibaba cluster H (Table 1). + + GPU Request per Task: 0, (0,1), 1, 2, 4, 8 + Task Population (%): 13.3, 37.8, 48.0, 0.2, 0.2, 0.5 + + For simplicity, we use average values for partial GPU tasks. + CPU demands are estimated based on typical CPU:GPU ratios. + """ + dist = TaskDistribution() + + # (cpu_demand, gpu_demand) -> popularity + # Assuming ~8 CPUs per GPU ratio on average + dist.add_task_type(cpu_demand=4.0, gpu_demand=0.0, popularity=0.133) # no GPU + dist.add_task_type(cpu_demand=4.0, gpu_demand=0.5, popularity=0.378) # partial GPU (avg 0.5) + dist.add_task_type(cpu_demand=8.0, gpu_demand=1.0, popularity=0.480) # 1 GPU + dist.add_task_type(cpu_demand=16.0, gpu_demand=2.0, popularity=0.002) # 2 GPUs + dist.add_task_type(cpu_demand=32.0, gpu_demand=4.0, popularity=0.002) # 4 GPUs + dist.add_task_type(cpu_demand=64.0, gpu_demand=8.0, popularity=0.005) # 8 GPUs + + dist.normalize() + return dist + + +if __name__ == "__main__": + # Simple test + print("=== Simulator Test ===\n") + + # Create a small cluster + cluster = Cluster() + cluster.create_homogeneous_cluster(num_nodes=3, cpu_per_node=64, gpus_per_node=4) + cluster.set_task_distribution(create_alibaba_like_distribution()) + + print(f"Cluster: {len(cluster.nodes)} nodes, {cluster.total_gpu_capacity} GPUs") + print(f"Initial fragmentation rate: {cluster.compute_fragmentation_rate():.2f}%") + + # Schedule some tasks + tasks = [ + Task(task_id=0, cpu_demand=8, gpu_demand=1.0), + Task(task_id=1, cpu_demand=4, gpu_demand=0.3), + Task(task_id=2, cpu_demand=4, gpu_demand=0.5), + Task(task_id=3, cpu_demand=8, gpu_demand=1.0), + ] + + for task in tasks: + eligible = cluster.get_eligible_nodes(task) + if eligible: + cluster.schedule_task(task, eligible[0].node_id) + print(f"Scheduled task {task.task_id} (GPU: {task.gpu_demand}) -> Node {eligible[0].node_id}") + + print(f"\nAfter scheduling:") + print(f" GPU allocation rate: {cluster.gpu_allocation_rate:.2f}%") + print(f" Fragmentation rate: {cluster.compute_fragmentation_rate():.2f}%") + + # Show node states + print(f"\nNode states:") + for node in cluster.nodes: + print(f" Node {node.node_id}: CPU {node.remaining_cpu:.0f}/{node.total_cpu:.0f}, " + f"GPUs {node.gpu_remaining}") diff --git a/standalone_fgd_replication/trace_loader.py b/standalone_fgd_replication/trace_loader.py new file mode 100644 index 0000000..8629cf0 --- /dev/null +++ b/standalone_fgd_replication/trace_loader.py @@ -0,0 +1,296 @@ +""" +Alibaba GPU Cluster Trace Loader (v2023) + +Parses the CSV trace files from Alibaba's cluster-trace-gpu-v2023 dataset. +Reference: https://github.com/alibaba/clusterdata +""" + +import csv +import os +from typing import List, Dict +from collections import Counter + +from simulator import Task, Node, Cluster, TaskDistribution + + +class AlibabaTraceLoader: + """ + Loader for Alibaba GPU cluster trace v2023. + """ + + def __init__(self, data_dir: str): + """ + Initialize the trace loader. + + Args: + data_dir: Path to the directory containing csv/ folder + """ + self.data_dir = data_dir + self.csv_dir = os.path.join(data_dir, 'csv') + self.tasks: List[Task] = [] + self.nodes: List[Node] = [] + + def load_nodes(self, filename: str = 'openb_node_list_gpu_node.csv') -> List[Node]: + """ + Load node information from CSV file. + + Args: + filename: Name of the node list CSV file + + Returns: + List of Node objects + """ + filepath = os.path.join(self.csv_dir, filename) + self.nodes = [] + + with open(filepath, 'r') as f: + reader = csv.DictReader(f) + for i, row in enumerate(reader): + node = Node( + node_id=i, + total_cpu=int(row['cpu_milli']) / 1000.0, + num_gpus=int(row['gpu']), + name=row['sn'], + gpu_model=row['model'] if row['model'] else '', + memory_mib=int(row['memory_mib']) + ) + self.nodes.append(node) + + return self.nodes + + def load_tasks(self, filename: str = 'openb_pod_list_default.csv') -> List[Task]: + """ + Load task information from CSV file. + + Args: + filename: Name of the pod list CSV file + + Returns: + List of Task objects sorted by creation_time + """ + filepath = os.path.join(self.csv_dir, filename) + self.tasks = [] + + with open(filepath, 'r') as f: + reader = csv.DictReader(f) + for i, row in enumerate(reader): + num_gpu = int(row['num_gpu']) + gpu_milli = int(row['gpu_milli']) + + # Compute GPU demand + if num_gpu == 0: + gpu_demand = 0.0 + elif num_gpu == 1: + # GPU-sharing task: use gpu_milli + gpu_demand = gpu_milli / 1000.0 + else: + # Multi-GPU task + gpu_demand = float(num_gpu) + + task = Task( + task_id=i, + cpu_demand=int(row['cpu_milli']) / 1000.0, + gpu_demand=gpu_demand, + name=row.get('name', ''), + creation_time=int(row['creation_time']) if row.get('creation_time') else 0, + scheduled_time=int(row['scheduled_time']) if row.get('scheduled_time') else 0, + deletion_time=int(row['deletion_time']) if row.get('deletion_time') else 0, + gpu_spec=row.get('gpu_spec', '') or '' + ) + self.tasks.append(task) + + # Sort by creation time + self.tasks.sort(key=lambda t: t.creation_time) + + # Re-assign task_id after sorting + for i, task in enumerate(self.tasks): + task.task_id = i + + return self.tasks + + def create_cluster(self) -> Cluster: + """ + Create a Cluster object from loaded nodes. + + Returns: + Cluster object with all nodes + """ + if not self.nodes: + self.load_nodes() + + cluster = Cluster() + for node in self.nodes: + cluster.add_node(node) + + return cluster + + def compute_task_distribution(self, popularity_threshold: float = None) -> TaskDistribution: + """ + Compute task distribution from loaded tasks. + Groups tasks by (cpu_demand, gpu_demand) and calculates popularity. + + Args: + popularity_threshold: If set, apply the paper's GetTypicalPods filter: + keep only the most popular types that together cover this percentage + of all tasks (sorted by count descending), then renormalize to sum=1. + Paper default: 60 (DefaultTypicalPodPopularityThreshold). + None = use all types. + + Returns: + TaskDistribution object + """ + if not self.tasks: + self.load_tasks() + + # Count task types + type_counts: Counter = Counter() + for task in self.tasks: + # Round GPU demand to 2 decimal places for grouping + gpu_rounded = round(task.gpu_demand, 2) + # Group CPU demands into buckets (to avoid too many types) + cpu_bucket = self._bucket_cpu(task.cpu_demand) + type_counts[(cpu_bucket, gpu_rounded)] += 1 + + total = sum(type_counts.values()) + + if popularity_threshold is not None: + # Paper's GetTypicalPods: keep top types covering popularity_threshold% of tasks. + # Sort by count descending, accumulate until cumulative count >= threshold. + # Then renormalize the selected types to sum to 1.0. + expected = popularity_threshold * total / 100.0 + sorted_types = sorted(type_counts.items(), key=lambda x: x[1], reverse=True) + selected = {} + cum = 0 + for type_key, count in sorted_types: + selected[type_key] = count + cum += count + if cum >= expected: + break + dist = TaskDistribution() + for (cpu, gpu), count in selected.items(): + dist.add_task_type(cpu, gpu, count / cum) + return dist + + # Convert to distribution (all types) + dist = TaskDistribution() + for (cpu, gpu), count in type_counts.items(): + dist.add_task_type(cpu, gpu, count / total) + + return dist + + def _bucket_cpu(self, cpu: float) -> float: + """Bucket CPU demand to reduce number of task types""" + # Round to nearest 4 CPUs + return round(cpu / 4) * 4 + + def get_statistics(self) -> Dict: + """ + Get statistics about the loaded trace. + + Returns: + Dictionary with trace statistics + """ + if not self.tasks: + self.load_tasks() + if not self.nodes: + self.load_nodes() + + # Task statistics + gpu_tasks = [t for t in self.tasks if t.gpu_demand > 0] + gpu_sharing_tasks = [t for t in self.tasks if 0 < t.gpu_demand < 1] + multi_gpu_tasks = [t for t in self.tasks if t.gpu_demand > 1] + one_gpu_tasks = [t for t in self.tasks if t.gpu_demand == 1.0] + no_gpu_tasks = [t for t in self.tasks if t.gpu_demand == 0] + + # GPU demand distribution + gpu_demands = Counter() + for t in self.tasks: + if t.gpu_demand == 0: + gpu_demands['0'] += 1 + elif t.gpu_demand < 1: + gpu_demands['(0,1)'] += 1 + elif t.gpu_demand == 1: + gpu_demands['1'] += 1 + else: + gpu_demands[str(int(t.gpu_demand))] += 1 + + # Node statistics + total_gpus = sum(n.num_gpus for n in self.nodes) + total_cpus = sum(n.total_cpu for n in self.nodes) + gpu_models = Counter(n.gpu_model for n in self.nodes) + + return { + 'num_tasks': len(self.tasks), + 'num_nodes': len(self.nodes), + 'total_gpus': total_gpus, + 'total_cpus': total_cpus, + 'gpu_tasks': len(gpu_tasks), + 'gpu_sharing_tasks': len(gpu_sharing_tasks), + 'one_gpu_tasks': len(one_gpu_tasks), + 'multi_gpu_tasks': len(multi_gpu_tasks), + 'no_gpu_tasks': len(no_gpu_tasks), + 'gpu_demand_distribution': dict(gpu_demands), + 'gpu_models': dict(gpu_models), + } + + +def print_trace_statistics(loader: AlibabaTraceLoader): + """Print formatted trace statistics""" + stats = loader.get_statistics() + + print("=" * 50) + print("Alibaba GPU Trace v2023 Statistics") + print("=" * 50) + + print(f"\nCluster:") + print(f" Nodes: {stats['num_nodes']}") + print(f" Total GPUs: {stats['total_gpus']}") + print(f" Total CPUs: {stats['total_cpus']:.0f}") + + print(f"\nTasks:") + print(f" Total: {stats['num_tasks']}") + print(f" GPU tasks: {stats['gpu_tasks']} ({100*stats['gpu_tasks']/stats['num_tasks']:.1f}%)") + print(f" GPU-sharing (partial): {stats['gpu_sharing_tasks']} ({100*stats['gpu_sharing_tasks']/stats['num_tasks']:.1f}%)") + print(f" One GPU: {stats['one_gpu_tasks']} ({100*stats['one_gpu_tasks']/stats['num_tasks']:.1f}%)") + print(f" Multi-GPU: {stats['multi_gpu_tasks']} ({100*stats['multi_gpu_tasks']/stats['num_tasks']:.1f}%)") + print(f" No GPU: {stats['no_gpu_tasks']} ({100*stats['no_gpu_tasks']/stats['num_tasks']:.1f}%)") + + print(f"\nGPU Demand Distribution:") + for demand, count in sorted(stats['gpu_demand_distribution'].items()): + pct = 100 * count / stats['num_tasks'] + print(f" {demand}: {count} ({pct:.1f}%)") + + print(f"\nGPU Models:") + for model, count in sorted(stats['gpu_models'].items(), key=lambda x: -x[1]): + print(f" {model}: {count} nodes") + + +if __name__ == "__main__": + # Test the trace loader + data_dir = os.path.join(os.path.dirname(__file__), '..', 'alibaba_traces', 'cluster-trace-gpu-v2023') + loader = AlibabaTraceLoader(data_dir) + + # Load data + loader.load_nodes() + loader.load_tasks() + + # Print statistics + print_trace_statistics(loader) + + # Test cluster creation + print("\n" + "=" * 50) + print("Testing Cluster Creation") + print("=" * 50) + + cluster = loader.create_cluster() + dist = loader.compute_task_distribution() + cluster.set_task_distribution(dist) + + print(f"\nCluster created: {len(cluster.nodes)} nodes, {cluster.total_gpu_capacity} GPUs") + print(f"Task distribution has {len(dist.distribution)} task types") + + # Show top task types + print("\nTop 10 task types by popularity:") + sorted_types = sorted(dist.distribution.items(), key=lambda x: -x[1]) + for (cpu, gpu), pop in sorted_types[:10]: + print(f" CPU={cpu:.0f}, GPU={gpu:.2f}: {100*pop:.2f}%")