[Benchmarks] Archive old data

Archive old benchmark data so it is not loaded in the dashboard.
The default value for archiving is:
- for Baseline_* runs for data older than 90 days,
- for all other runs for data older than 14 days.

Add a UI option for loading archived data.

Author: PatKamin

devops/scripts/benchmarks/history.py

@@ -9,7 +9,7 @@
 import socket
 from utils.result import Result, BenchmarkRun
 from options import Compare, options
-from datetime import datetime, timezone
+from datetime import datetime, timezone, timedelta
 from utils.utils import run
 from utils.validate import Validate
 
@@ -223,3 +223,23 @@ def get_compare(self, name: str) -> BenchmarkRun:
             return self.compute_average(data)
 
         raise Exception("invalid compare type")
+
+    def partition_runs_by_age(self) -> tuple[list[BenchmarkRun], list[BenchmarkRun]]:
+        """
+        Partition runs into current and archived based on their age.
+        Returns:
+            tuple: (current_runs, archived_runs)
+        """
+        current_runs = []
+        archived_runs = []
+
+        for run in self.runs:
+            archive_after =  options.archive_baseline_days if run.name.startswith("Baseline_") else options.archive_pr_days
+            cutoff_date = datetime.now(timezone.utc) - timedelta(days=archive_after)
+
+            if run.date > cutoff_date:
+                current_runs.append(run)
+            else:
+                archived_runs.append(run)
+
+        return current_runs, archived_runs

devops/scripts/benchmarks/html/index.html

@@ -53,6 +53,10 @@ <h3>Display Options</h3>
                             <input type="checkbox" id="custom-range">
                             Adjust Y-axis for comparisons
                         </label>
+                        <label title="Load older benchmark results that have been archived.">
+                            <input type="checkbox" id="show-archived-data">
+                            Include archived runs
+                        </label>
                     </div>
                 </div>
 

devops/scripts/benchmarks/html/scripts.js

@@ -7,13 +7,14 @@
 let activeRuns = new Set(defaultCompareNames);
 let chartInstances = new Map();
 let suiteNames = new Set();
-let timeseriesData, barChartsData, allRunNames;
 let activeTags = new Set();
+let timeseriesData, barChartsData, allRunNames;
 let layerComparisonsData;
 let latestRunsLookup = new Map();
 let pendingCharts = new Map(); // Store chart data for lazy loading
 let chartObserver; // Intersection observer for lazy loading charts
 let annotationsOptions = new Map(); // Global options map for annotations
+let archivedDataLoaded = false;
 
 // DOM Elements
 let runSelect, selectedRunsDiv, suiteFiltersContainer, tagFiltersContainer;
@@ -577,6 +578,12 @@ function updateURL() {
     } else {
         url.searchParams.set('customRange', 'true');
     }
+    
+    if (!isArchivedDataEnabled()) {
+        url.searchParams.delete('archived');
+    } else {
+        url.searchParams.set('archived', 'true');
+    }
 
     history.replaceState(null, '', url);
 }
@@ -835,6 +842,9 @@ function setupRunSelector() {
     runSelect = document.getElementById('run-select');
     selectedRunsDiv = document.getElementById('selected-runs');
 
+    // Clear existing options first to prevent duplicates when reloading with archived data
+    runSelect.innerHTML = '';
+
     allRunNames.forEach(name => {
         const option = document.createElement('option');
         option.value = name;
@@ -848,6 +858,9 @@ function setupRunSelector() {
 function setupSuiteFilters() {
     suiteFiltersContainer = document.getElementById('suite-filters');
 
+    // Clear existing suite filters before adding new ones
+    suiteFiltersContainer.innerHTML = '';
+
     benchmarkRuns.forEach(run => {
         run.results.forEach(result => {
             suiteNames.add(result.suite);
@@ -883,10 +896,16 @@ function isCustomRangesEnabled() {
     return rangesToggle.checked;
 }
 
+function isArchivedDataEnabled() {
+    const archivedDataToggle = document.getElementById('show-archived-data');
+    return archivedDataToggle.checked;
+}
+
 function setupToggles() {
     const notesToggle = document.getElementById('show-notes');
     const unstableToggle = document.getElementById('show-unstable');
     const customRangeToggle = document.getElementById('custom-range');
+    const archivedDataToggle = document.getElementById('show-archived-data');
 
     notesToggle.addEventListener('change', function () {
         // Update all note elements visibility
@@ -908,10 +927,26 @@ function setupToggles() {
         // redraw all charts
         updateCharts();
     });
+    
+    // Add event listener for archived data toggle
+    if (archivedDataToggle) {
+        archivedDataToggle.addEventListener('change', function() {
+            if (archivedDataToggle.checked) {
+                loadArchivedData();
+            } else {
+                if (archivedDataLoaded) {
+                    // Reload the page to reset
+                    location.reload();
+                }
+            }
+            updateURL();
+        });
+    }
 
     // Initialize from URL params if present
     const notesParam = getQueryParam('notes');
     const unstableParam = getQueryParam('unstable');
+    const archivedParam = getQueryParam('archived');
 
     if (notesParam !== null) {
         let showNotes = notesParam === 'true';
@@ -927,11 +962,22 @@ function setupToggles() {
     if (customRangesParam !== null) {
         customRangeToggle.checked = customRangesParam === 'true';
     }
+    
+    if (archivedDataToggle && archivedParam !== null) {
+        archivedDataToggle.checked = archivedParam === 'true';
+        
+        if (archivedDataToggle.checked) {
+            loadArchivedData();
+        }
+    }
 }
 
 function setupTagFilters() {
     tagFiltersContainer = document.getElementById('tag-filters');
 
+    // Clear existing tag filters before adding new ones
+    tagFiltersContainer.innerHTML = '';
+
     const allTags = [];
 
     if (benchmarkTags) {
@@ -1119,6 +1165,94 @@ function loadData() {
     }
 }
 
+// Function to load archived data and merge with current data
+// Archived data consists of older benchmark results that have been separated from
+// the primary dataset but are still available for historical analysis.
+function loadArchivedData() {
+    const loadingIndicator = document.getElementById('loading-indicator');
+    loadingIndicator.style.display = 'block';
+    
+    if (archivedDataLoaded) {
+        updateCharts();
+        loadingIndicator.style.display = 'none';
+        return;
+    }
+    
+    if (typeof remoteDataUrl !== 'undefined' && remoteDataUrl !== '') {
+        // For remote data, construct the archive URL by adding _archive before the extension
+        const archiveUrl = remoteDataUrl.replace(/(\.[^.]+)$/, '_archive$1');
+        
+        fetch(archiveUrl)
+            .then(response => {
+                if (!response.ok) { throw new Error(`Got response status ${response.status}.`) }
+                return response.json();
+            })
+            .then(data => {
+                const archivedRuns = data.runs || data;
+                
+                // Merge the archived runs with current runs
+                benchmarkRuns = benchmarkRuns.concat(archivedRuns);
+                
+                // Merge metadata and tags if available
+                if (data.metadata) {
+                    benchmarkMetadata = { ...benchmarkMetadata, ...data.metadata };
+                }
+                
+                if (data.tags) {
+                    benchmarkTags = { ...benchmarkTags, ...data.tags };
+                }
+                
+                archivedDataLoaded = true;
+                initializeCharts();
+            })
+            .catch(error => {
+                console.error('Error fetching archived data:', error);
+            })
+            .finally(() => {
+                loadingIndicator.style.display = 'none';
+            });
+    } else {
+        // For local data, try to load data_archive.js
+        const script = document.createElement('script');
+        script.src = 'data_archive.js';
+        script.onload = () => {
+            if (typeof archivedBenchmarkRuns !== 'undefined') {
+                // Merge the archived runs with current runs
+                benchmarkRuns = benchmarkRuns.concat(archivedBenchmarkRuns);
+                
+                // Merge metadata and tags if available
+                if (typeof archivedBenchmarkMetadata !== 'undefined') {
+                    benchmarkMetadata = { ...benchmarkMetadata, ...archivedBenchmarkMetadata };
+                }
+                
+                if (typeof archivedBenchmarkTags !== 'undefined') {
+                    benchmarkTags = { ...benchmarkTags, ...archivedBenchmarkTags };
+                }
+                
+                archivedDataLoaded = true;
+                
+                archivedBenchmarkRuns.forEach(runName => {
+                    if (!activeRuns.has(runName)) {
+                        activeRuns.add(runName);
+                    }
+                });
+                
+                initializeCharts();
+            } else {
+                console.error('Archived runs data not found in data_archive.js');
+            }
+            loadingIndicator.style.display = 'none';
+        };
+        
+        script.onerror = () => {
+            console.error('Failed to load data_archive.js');
+            loadingIndicator.style.display = 'none';
+        };
+        
+        document.head.appendChild(script);
+    }
+}
+
 // Initialize when DOM is ready
 document.addEventListener('DOMContentLoaded', () => {
     loadData();

devops/scripts/benchmarks/main.py

@@ -316,7 +316,7 @@ def main(directory, additional_env_vars, save_name, compare_names, filter):
         if options.output_directory is None:
             html_path = os.path.join(os.path.dirname(__file__), "html")
 
-        generate_html(history.runs, compare_names, html_path, metadata)
+        generate_html(history, compare_names, html_path, metadata)
 
 
 def validate_and_parse_env_args(env_args):
@@ -558,6 +558,22 @@ def validate_and_parse_env_args(env_args):
         help="Location of detect_version.cpp used to query e.g. DPC++, L0",
         default=None,
     )
+    parser.add_argument(
+        "--archive-baseline-after",
+        type=int,
+        help="Archive baseline results (runs starting with 'Baseline_') older than this many days. "
+             "Archived results are stored separately and can be viewed in the HTML UI by enabling "
+             "'Include archived runs'. This helps manage the size of the primary dataset.",
+        default=options.archive_baseline_days,
+    )
+    parser.add_argument(
+        "--archive-pr-after",
+        type=int,
+        help="Archive PR and other non-baseline results older than this many days. "
+             "Archived results are stored separately and can be viewed in the HTML UI by enabling "
+             "'Include archived runs'. PR runs typically have a shorter retention period than baselines.",
+        default=options.archive_pr_days,
+    )
 
     args = parser.parse_args()
     additional_env_vars = validate_and_parse_env_args(args.env)

devops/scripts/benchmarks/options.py

@@ -2,8 +2,6 @@
 from enum import Enum
 import multiprocessing
 
-from presets import presets
-
 
 class Compare(Enum):
     LATEST = "latest"
@@ -88,6 +86,12 @@ class Options:
     # CI scripts vs SYCl build source.
     github_repo_override: str = None
     git_commit_override: str = None
+    # Archiving settings
+    # Archived runs are stored separately from the main dataset but are still accessible
+    # via the HTML UI when "Include archived runs" is enabled
+    archive_baseline_days: int = 90     # Archive Baseline_* runs after 90 days
+    archive_pr_days: int = 14           # Archive other (PR/dev) runs after 14 days
+
 
     detect_versions: DetectVersionsOptions = field(
         default_factory=DetectVersionsOptions