[PATCH 0/7] Core sharing validation for CPU isolation

[PATCH 0/7] Core sharing validation for CPU isolation

[John Kacur]

This patch series adds validation to detect and warn when CPUs sharing
physical cores (SMT siblings) are assigned to different workload types,
which can defeat CPU isolation and corrupt real-time measurements.

When SMT/hyperthreading is enabled, CPUs sharing a physical core also
share L1/L2 caches, execution units, TLB, and other core-level resources.
Running different workload types (housekeeping, measurement, load) on
sibling threads defeats CPU isolation and can create unreproducible
results.

The series implements:

1. CoreSiblings class - Provides a simple interface for querying which
   CPUs share physical cores by reading thread_siblings_list from sysfs.
   Works with any SMT configuration (1-way, 2-way, 4-way, 8-way).

2. Core sharing validation - Detects when isolated CPUs share cores
   between housekeeping, measurement, and load groups. Warnings are
   logged to console and included in XML reports.

3. XSLT integration - Warnings appear in text reports generated with
   the -Z option via a CoreSharingWarnings section.

4. Optional stricter validation - --warn-non-isolated-core-sharing
   flag enables warnings for measurement vs load CPU pairs even when
   neither is isolated, for users who want maximum isolation assurance.

The validation is purely informational - it warns users but does not
prevent execution, allowing informed decisions about CPU configurations.

Testing includes comprehensive scenarios with both isolated and
non-isolated CPU configurations, verified with real isolated CPUs.

John Kacur (7):
  rteval: Add CoreSiblings class for CPU core topology queries
  rteval: Add core sharing validation for CPU isolation
  rteval: Include core sharing warnings in XML report
  rteval: Add temporary test for core sharing validation with mocked
    isolated CPUs
  rteval: Display core sharing warnings in text report
  rteval: Add --warn-non-isolated-core-sharing option for measurement vs
    load warnings
  rteval: Include --warn-non-isolated-core-sharing warnings in XML
    report

 rteval-cmd                     |  18 +++-
 rteval/rteval_text.xsl         |  13 ++-
 rteval/sysinfo/__init__.py     |   3 +
 rteval/sysinfo/coresiblings.py | 116 +++++++++++++++++++++++++
 rteval/sysinfo/cputopology.py  |  35 ++++++++
 rteval/systopology.py          |  64 ++++++++++++++
 test_full_validation.py        | 151 +++++++++++++++++++++++++++++++++
 7 files changed, 398 insertions(+), 2 deletions(-)
 create mode 100644 rteval/sysinfo/coresiblings.py
 create mode 100644 test_full_validation.py

-- 
2.53.0

[PATCH 1/7] rteval: Add CoreSiblings class for CPU core topology queries

[John Kacur]

Add a new CoreSiblings class in rteval/sysinfo/coresiblings.py that
provides a simple interface for querying which CPUs share physical cores.

The class reads /sys/devices/system/cpu/cpu*/topology/thread_siblings_list
to build a mapping of CPU core siblings and provides three methods:

- share_core(cpu1, cpu2): Check if two CPUs share a physical core
- get_siblings(cpu): Get all CPUs that share a core with a given CPU
- get_core_groups(): Get all unique core sibling groups

The implementation is generic and works with any SMT configuration:
- No SMT (1 CPU per core)
- 2-way SMT (typical Intel hyperthreading)
- 4-way SMT (some IBM POWER processors)
- 8-way SMT (IBM POWER8/9)

This provides a foundation for cpuset management features where we need
to understand CPU core topology for proper isolation.

Assisted-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: John Kacur <jkacur@redhat.com>
---
 rteval/sysinfo/coresiblings.py | 110 +++++++++++++++++++++++++++++++++
 1 file changed, 110 insertions(+)
 create mode 100644 rteval/sysinfo/coresiblings.py

diff --git a/rteval/sysinfo/coresiblings.py b/rteval/sysinfo/coresiblings.py
new file mode 100644
index 000000000000..3c97439d0a39
--- /dev/null
+++ b/rteval/sysinfo/coresiblings.py
@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+# SPDX-License-Identifier: GPL-2.0-or-later
+#
+#   Copyright 2026   John Kacur <jkacur@redhat.com>
+#
+
+import os
+from rteval.cpulist_utils import expand_cpulist
+
+class CoreSiblings:
+    """Query CPU core topology to determine which CPUs share physical cores"""
+
+    def __init__(self, root="/"):
+        self.sysdir = os.path.join(root, 'sys', 'devices', 'system', 'cpu')
+        self.core_map = {}  # Maps cpu -> set of sibling cpus
+        self._parse()
+
+    def _parse(self):
+        """Parse thread_siblings_list for each CPU"""
+        for dirname in os.listdir(self.sysdir):
+            # Only parse cpu<integer> directories
+            if dirname.startswith('cpu') and os.path.isdir(os.path.join(self.sysdir, dirname)):
+                try:
+                    cpu_id = int(dirname[3:])
+                except ValueError:
+                    continue
+
+                siblings_file = os.path.join(self.sysdir, dirname, 'topology', 'thread_siblings_list')
+                if os.path.exists(siblings_file):
+                    with open(siblings_file, 'r') as f:
+                        siblings_str = f.read().strip()
+                        # expand_cpulist returns a list of cpu numbers
+                        siblings = set(expand_cpulist(siblings_str))
+                        self.core_map[cpu_id] = siblings
+
+    def share_core(self, cpu1, cpu2):
+        """
+        Check if two CPUs share the same physical core.
+
+        Args:
+            cpu1: First CPU ID (int)
+            cpu2: Second CPU ID (int)
+
+        Returns:
+            True if CPUs share a core, False otherwise
+        """
+        if cpu1 not in self.core_map:
+            return False
+        return cpu2 in self.core_map[cpu1]
+
+    def get_siblings(self, cpu):
+        """
+        Get all CPUs that share a core with the given CPU.
+
+        Args:
+            cpu: CPU ID (int)
+
+        Returns:
+            Set of CPU IDs that share a core with cpu (includes cpu itself)
+        """
+        return self.core_map.get(cpu, set())
+
+    def get_core_groups(self):
+        """
+        Get all unique core sibling groups.
+
+        Returns:
+            List of sets, where each set contains CPUs that share a core
+        """
+        seen = set()
+        groups = []
+
+        for cpu, siblings in self.core_map.items():
+            # Use frozenset as a hashable representation
+            group_key = frozenset(siblings)
+            if group_key not in seen:
+                seen.add(group_key)
+                groups.append(siblings)
+
+        return groups
+
+
+def unit_test():
+    """Simple unit test"""
+    try:
+        cs = CoreSiblings()
+
+        print("Core Sibling Groups:")
+        for i, group in enumerate(cs.get_core_groups()):
+            print(f"  Core {i}: {sorted(group)}")
+
+        # Test share_core with first two CPUs if they exist
+        if len(cs.core_map) >= 2:
+            cpus = sorted(cs.core_map.keys())
+            cpu1, cpu2 = cpus[0], cpus[1]
+            print(f"\nDo CPU {cpu1} and CPU {cpu2} share a core? {cs.share_core(cpu1, cpu2)}")
+            print(f"CPU {cpu1} siblings: {sorted(cs.get_siblings(cpu1))}")
+            print(f"CPU {cpu2} siblings: {sorted(cs.get_siblings(cpu2))}")
+
+        return 0
+    except Exception as e:
+        print(f"** EXCEPTION: {e}")
+        import traceback
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == '__main__':
+    import sys
+    sys.exit(unit_test())
-- 
2.53.0

[PATCH 2/7] rteval: Add core sharing validation for CPU isolation

[John Kacur]

Add validation to detect and warn when CPUs sharing physical cores are
assigned to different workload types (housekeeping, measurement, load).

When SMT/hyperthreading is enabled, CPUs sharing a physical core also
share L1/L2 caches, execution units, TLB, and other core-level resources.
Running different workload types on sibling threads defeats CPU isolation
and can corrupt real-time measurements or create unreproducible results.

Key features:
- Uses CoreSiblings class to detect which CPUs share physical cores
- Only warns when at least one CPU in a pair is isolated (via isolcpus)
- Checks all three workload type combinations:
  * Housekeeping vs Measurement
  * Housekeeping vs Load
  * Measurement vs Load
- Warning format clearly indicates which CPUs are isolated with "(isol)"
  marker

Example warning:
  Warning: Housekeeping CPU 0 (isol) shares core with measurement CPU 8 (isol)

Implementation:
- coresiblings.py: Add comment explaining SMT-enabled/disabled behavior
- systopology.py: Add validate_core_sharing() function
- rteval-cmd: Call validation after CPU lists are finalized and log warnings

This validation is purely informational - it warns users but does not
prevent execution, allowing users to make informed decisions about their
CPU configurations.

Assisted-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: John Kacur <jkacur@redhat.com>
---
 rteval-cmd                     |  8 ++++-
 rteval/sysinfo/coresiblings.py |  8 ++++-
 rteval/systopology.py          | 55 ++++++++++++++++++++++++++++++++++
 3 files changed, 69 insertions(+), 2 deletions(-)

diff --git a/rteval-cmd b/rteval-cmd
index a903b537c891..f0efb0117726 100755
--- a/rteval-cmd
+++ b/rteval-cmd
@@ -31,7 +31,7 @@ from rteval.modules.loads import LoadModules
 from rteval.modules.measurement import MeasurementModules
 from rteval import cpupower
 from rteval.version import RTEVAL_VERSION
-from rteval.systopology import SysTopology, parse_cpulist_from_config, validate_housekeeping_cpus
+from rteval.systopology import SysTopology, parse_cpulist_from_config, validate_housekeeping_cpus, validate_core_sharing
 from rteval.modules.loads.kcompile import ModuleParameters
 from rteval.cpulist_utils import CpuList, is_relative, collapse_cpulist
 
@@ -446,6 +446,12 @@ if __name__ == '__main__':
             logger.log(Log.DEBUG, f"measurement cpulist: {msrcfg.cpulist}")
         logger.log(Log.DEBUG, f"workdir: {rtevcfg.workdir}")
 
+        # Validate core sharing between housekeeping, measurement, and load CPUs
+        if housekeeping_cpus or msrcfg_cpus or ldcfg_cpus:
+            core_warnings = validate_core_sharing(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus)
+            for warning in core_warnings:
+                logger.log(Log.WARN, warning)
+
         # if --summarize was specified then just parse the XML, print it and exit
         if cmd_opts.rteval___summarize:
             for xmlfile in cmd_opts.rteval___summarize:
diff --git a/rteval/sysinfo/coresiblings.py b/rteval/sysinfo/coresiblings.py
index 3c97439d0a39..d55a4b699149 100644
--- a/rteval/sysinfo/coresiblings.py
+++ b/rteval/sysinfo/coresiblings.py
@@ -8,7 +8,13 @@ import os
 from rteval.cpulist_utils import expand_cpulist
 
 class CoreSiblings:
-    """Query CPU core topology to determine which CPUs share physical cores"""
+    """
+    Query CPU core topology to determine which CPUs share physical cores
+
+    Note: This class works correctly whether SMT/hyperthreading is enabled or disabled.
+    When SMT is disabled, each CPU's thread_siblings_list contains only itself,
+    so the class will correctly report that no CPUs share cores.
+    """
 
     def __init__(self, root="/"):
         self.sysdir = os.path.join(root, 'sys', 'devices', 'system', 'cpu')
diff --git a/rteval/systopology.py b/rteval/systopology.py
index 5f2bc291f608..0ee81d5c5e36 100644
--- a/rteval/systopology.py
+++ b/rteval/systopology.py
@@ -294,6 +294,61 @@ def parse_cpulist_from_config(cpulist, run_on_isolcpus=False):
     return result
 
 
+def validate_core_sharing(housekeeping_cpus, measurement_cpus, load_cpus):
+    """
+    Check for CPUs sharing physical cores across different workload types.
+    Warns if isolated CPUs share cores between housekeeping, measurement, and load groups.
+
+    :param housekeeping_cpus: List of housekeeping CPU integers
+    :param measurement_cpus: List of measurement CPU integers
+    :param load_cpus: List of load CPU integers
+    :return: List of warning messages (empty if no issues)
+    """
+    from rteval.sysinfo.coresiblings import CoreSiblings
+
+    warnings = []
+
+    # Get isolated CPUs
+    isolated_cpus = set(SysTopology().isolated_cpus())
+
+    # Create CoreSiblings instance
+    try:
+        cs = CoreSiblings()
+    except Exception:
+        # If we can't read topology, skip validation
+        return warnings
+
+    def check_pair(cpu1, cpu2, type1, type2):
+        """Check if two CPUs share a core and generate warning if at least one is isolated"""
+        if cs.share_core(cpu1, cpu2):
+            cpu1_isol = cpu1 in isolated_cpus
+            cpu2_isol = cpu2 in isolated_cpus
+
+            # Only warn if at least one CPU is isolated
+            if cpu1_isol or cpu2_isol:
+                cpu1_str = f"{type1} CPU {cpu1}{' (isol)' if cpu1_isol else ''}"
+                cpu2_str = f"{type2} CPU {cpu2}{' (isol)' if cpu2_isol else ''}"
+                warnings.append(f"Warning: {cpu1_str} shares core with {cpu2_str}")
+
+    # Check all three combinations
+    # 1. Housekeeping vs Measurement
+    for hk_cpu in housekeeping_cpus:
+        for msr_cpu in measurement_cpus:
+            check_pair(hk_cpu, msr_cpu, "Housekeeping", "measurement")
+
+    # 2. Housekeeping vs Load
+    for hk_cpu in housekeeping_cpus:
+        for ld_cpu in load_cpus:
+            check_pair(hk_cpu, ld_cpu, "Housekeeping", "load")
+
+    # 3. Measurement vs Load
+    for msr_cpu in measurement_cpus:
+        for ld_cpu in load_cpus:
+            check_pair(msr_cpu, ld_cpu, "Measurement", "load")
+
+    return warnings
+
+
 if __name__ == "__main__":
 
     def unit_test():
-- 
2.53.0

[PATCH 3/7] rteval: Include core sharing warnings in XML report

[John Kacur]

Add core sharing validation warnings to the CPUtopology section of the
XML report, making isolation issues part of the permanent test record.

This complements the console warnings added in the previous commit by
ensuring that core sharing conflicts are documented in the XML output,
allowing users to analyze test runs later even if they missed the
console warnings during execution.

Implementation:
- CPUtopology.add_core_sharing_warnings(): New method to add warnings
  to the CPUtopology XML node after CPU lists are finalized
- rteval-cmd: Call add_core_sharing_warnings() after RtEval object is
  created and CPU lists are available
- XML structure: CoreSharingWarnings appears at the end of CPUtopology
  node, after all CPU entries and summary properties

Note: The warnings must be added after SystemInfo initialization because
CPU lists are finalized in rteval-cmd after the config is processed,
which happens after SystemInfo is created. We call the method explicitly
once the CPU lists are known.

Example XML output:
  <CPUtopology num_cpu_cores="16" ...>
    <cpu name="cpu0" ... isolated="1"/>
    <cpu name="cpu8" ... isolated="1"/>
    ...
    <CoreSharingWarnings>
      <warning>Warning: Housekeeping CPU 0 (isol) shares core with measurement CPU 8 (isol)</warning>
    </CoreSharingWarnings>
  </CPUtopology>

The warnings use the same format as console output, clearly indicating
which CPUs are isolated with "(isol)" markers.

Assisted-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: John Kacur <jkacur@redhat.com>
---
 rteval-cmd                    | 13 +++++++++----
 rteval/sysinfo/__init__.py    |  3 +++
 rteval/sysinfo/cputopology.py | 33 +++++++++++++++++++++++++++++++++
 3 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/rteval-cmd b/rteval-cmd
index f0efb0117726..b3f9fac2c2cf 100755
--- a/rteval-cmd
+++ b/rteval-cmd
@@ -447,10 +447,11 @@ if __name__ == '__main__':
         logger.log(Log.DEBUG, f"workdir: {rtevcfg.workdir}")
 
         # Validate core sharing between housekeeping, measurement, and load CPUs
-        if housekeeping_cpus or msrcfg_cpus or ldcfg_cpus:
-            core_warnings = validate_core_sharing(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus)
-            for warning in core_warnings:
-                logger.log(Log.WARN, warning)
+        msrcfg_cpus = CpuList(msrcfg.cpulist).cpus if msrcfg.cpulist else []
+        ldcfg_cpus = CpuList(ldcfg.cpulist).cpus if ldcfg.cpulist else []
+        core_warnings = validate_core_sharing(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus)
+        for warning in core_warnings:
+            logger.log(Log.WARN, warning)
 
         # if --summarize was specified then just parse the XML, print it and exit
         if cmd_opts.rteval___summarize:
@@ -487,6 +488,10 @@ if __name__ == '__main__':
             cpupower_controller.enable_idle_state()
 
         rteval = RtEval(config, loadmods, measuremods, logger)
+
+        # Add core sharing warnings to the XML report now that CPU lists are finalized
+        rteval._sysinfo.add_core_sharing_warnings(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus)
+
         rteval.Prepare(rtevcfg.onlyload)
 
         if rtevcfg.onlyload:
diff --git a/rteval/sysinfo/__init__.py b/rteval/sysinfo/__init__.py
index 4b7b03cda626..56a0c57b2cbc 100644
--- a/rteval/sysinfo/__init__.py
+++ b/rteval/sysinfo/__init__.py
@@ -35,6 +35,9 @@ class SystemInfo(KernelInfo, SystemServices, dmi.DMIinfo, CPUtopology,
         self.ProcessWarnings()
 
         # Parse CPU info
+        # Note: CPU lists are not available at this point (they're finalized in rteval-cmd),
+        # so we can't add core sharing warnings to the XML report yet.
+        # Console warnings are still generated in rteval-cmd.
         CPUtopology._parse(self)
 
 
diff --git a/rteval/sysinfo/cputopology.py b/rteval/sysinfo/cputopology.py
index db30635a0488..a21c19179f28 100644
--- a/rteval/sysinfo/cputopology.py
+++ b/rteval/sysinfo/cputopology.py
@@ -94,6 +94,39 @@ class CPUtopology:
         return self.__cputop_n
 
 
+    def add_core_sharing_warnings(self, housekeeping_cpus, measurement_cpus, load_cpus):
+        """
+        Add core sharing warnings to the CPUtopology XML node.
+        Should be called after CPU lists are finalized.
+
+        :param housekeeping_cpus: List of housekeeping CPU integers
+        :param measurement_cpus: List of measurement CPU integers
+        :param load_cpus: List of load CPU integers
+        """
+        if self.__cputop_n is None:
+            return
+
+        # Remove any existing CoreSharingWarnings section
+        existing = self.__cputop_n.xpathEval('CoreSharingWarnings')
+        if existing:
+            for node in existing:
+                node.unlinkNode()
+                node.freeNode()
+
+        # Generate new warnings
+        from rteval.systopology import validate_core_sharing
+        warnings = validate_core_sharing(
+            housekeeping_cpus or [],
+            measurement_cpus or [],
+            load_cpus or []
+        )
+
+        # Add warnings to XML if any were found
+        if warnings:
+            warnings_n = self.__cputop_n.newChild(None, 'CoreSharingWarnings', None)
+            for warning in warnings:
+                warnings_n.newChild(None, 'warning', warning)
+
     def MakeReport(self):
         return self.__cputop_n
 
-- 
2.53.0

[PATCH 4/7] rteval: Add temporary test for core sharing validation with mocked isolated CPUs

[John Kacur]

Add comprehensive test script to validate core sharing warnings without
requiring actual isolated CPUs. This test uses mocked isolated CPUs to
verify both console warnings and XML report generation.

The test simulates CPUs 0, 8, 1, 9 as isolated and validates:
- Console warnings are generated correctly
- XML CoreSharingWarnings section is properly added
- Warnings only appear when at least one CPU is isolated
- Warning format includes "(isol)" markers correctly

This is a temporary test file for development and verification.
It can be removed once the feature is tested with real isolated CPUs.

Test results show all functionality working correctly:
- Console warnings: 3/3 scenarios pass
- XML generation: warnings properly added to CPUtopology section

Signed-off-by: John Kacur <jkacur@redhat.com>
---
 test_full_validation.py | 151 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 151 insertions(+)
 create mode 100644 test_full_validation.py

diff --git a/test_full_validation.py b/test_full_validation.py
new file mode 100644
index 000000000000..98c286fab344
--- /dev/null
+++ b/test_full_validation.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+"""
+Test core sharing validation with mocked isolated CPUs
+Tests both console warnings and XML output
+"""
+
+import sys
+sys.path.insert(0, '.')
+
+from unittest.mock import patch, Mock
+import libxml2
+from rteval.systopology import validate_core_sharing
+
+# Mock isolated CPUs: simulate CPUs 0, 8, 1, 9 as isolated
+# Based on actual topology: CPUs 0 and 8 share a core, 1 and 9 share a core
+MOCK_ISOLATED_CPUS = [0, 8, 1, 9]
+
+print("=" * 70)
+print("TESTING CORE SHARING VALIDATION")
+print("=" * 70)
+print()
+print("System core topology (from actual hardware):")
+from rteval.sysinfo.coresiblings import CoreSiblings
+cs = CoreSiblings()
+for i, group in enumerate(cs.get_core_groups()[:4]):
+    print(f"  Core {i}: {sorted(group)}")
+print()
+print(f"Simulating isolated CPUs: {MOCK_ISOLATED_CPUS}")
+print()
+
+# Test 1: Console warnings
+print("=" * 70)
+print("TEST 1: Console Warnings")
+print("=" * 70)
+print()
+
+with patch('rteval.systopology.SysTopology') as mock_systopo:
+    mock_instance = mock_systopo.return_value
+    mock_instance.isolated_cpus.return_value = MOCK_ISOLATED_CPUS
+
+    print("Scenario 1: Housekeeping and Measurement share core")
+    print("  Housekeeping: [0]  (isolated)")
+    print("  Measurement:  [8]  (isolated, shares core with 0)")
+    print("  Load:         [2]  (non-isolated)")
+    warnings = validate_core_sharing([0], [8], [2])
+    if warnings:
+        print(f"  ✓ Got {len(warnings)} warning(s):")
+        for w in warnings:
+            print(f"    {w}")
+    else:
+        print("  ✗ No warnings!")
+    print()
+
+    print("Scenario 2: All three workload types on different cores")
+    print("  Housekeeping: [0]  (isolated)")
+    print("  Measurement:  [1]  (isolated, different core)")
+    print("  Load:         [2]  (non-isolated, different core)")
+    warnings = validate_core_sharing([0], [1], [2])
+    if warnings:
+        print(f"  ✗ Unexpected warnings: {warnings}")
+    else:
+        print("  ✓ No warnings (correct!)")
+    print()
+
+    print("Scenario 3: Multiple conflicts")
+    print("  Housekeeping: [0]     (isolated)")
+    print("  Measurement:  [8]     (isolated, shares core with 0)")
+    print("  Load:         [1,9]   (1 and 9 both isolated, share a core)")
+    warnings = validate_core_sharing([0], [8], [1, 9])
+    if warnings:
+        print(f"  ✓ Got {len(warnings)} warning(s):")
+        for w in warnings:
+            print(f"    {w}")
+    else:
+        print("  ✗ No warnings!")
+    print()
+
+# Test 2: XML output
+print("=" * 70)
+print("TEST 2: XML Report Generation")
+print("=" * 70)
+print()
+
+with patch('rteval.systopology.SysTopology') as mock_systopo:
+    mock_instance = mock_systopo.return_value
+    mock_instance.isolated_cpus.return_value = MOCK_ISOLATED_CPUS
+    mock_instance.isolated_cpus_str.return_value = [str(cpu) for cpu in MOCK_ISOLATED_CPUS]
+
+    from rteval.sysinfo.cputopology import CPUtopology
+    from rteval.Log import Log
+
+    # Create CPUtopology and parse
+    cputop = CPUtopology()
+    cputop._parse()
+
+    # Now add warnings with conflicting CPU lists
+    print("Adding warnings for:")
+    print("  Housekeeping: [0]  (isolated)")
+    print("  Measurement:  [8]  (isolated, shares core with 0)")
+    print("  Load:         [1,9] (both isolated, share core with each other)")
+    print()
+
+    # First verify that validation itself works with the mock
+    from rteval.systopology import validate_core_sharing
+    test_warnings = validate_core_sharing([0], [8], [1, 9])
+    print(f"Direct validation call returned {len(test_warnings)} warning(s)")
+    print()
+
+    cputop.add_core_sharing_warnings([0], [8], [1, 9])
+
+    # Get the XML
+    xml = cputop.MakeReport()
+
+    # Check for warnings in XML
+    # Search for CoreSharingWarnings child node
+    warnings_section = None
+    child = xml.children
+    while child:
+        if child.name == 'CoreSharingWarnings':
+            warnings_section = child
+            break
+        child = child.next
+
+    if warnings_section:
+        warning_list = []
+        warning_child = warnings_section.children
+        while warning_child:
+            if warning_child.name == 'warning':
+                warning_list.append(warning_child.getContent())
+            warning_child = warning_child.next
+
+        if warning_list:
+            print(f"✓ Found {len(warning_list)} warning(s) in XML:")
+            for w in warning_list:
+                print(f"  - {w}")
+        else:
+            print("✗ CoreSharingWarnings section exists but is empty!")
+    else:
+        print("✗ No CoreSharingWarnings section found in XML!")
+
+    print()
+    print("Full CPUtopology XML section:")
+    print("-" * 70)
+    temp_doc = libxml2.newDoc("1.0")
+    temp_doc.setRootElement(xml.docCopyNode(temp_doc, 1))
+    temp_doc.saveFormatFileEnc("-", "UTF-8", 1)
+
+print()
+print("=" * 70)
+print("ALL TESTS COMPLETE")
+print("=" * 70)
-- 
2.53.0

[PATCH 5/7] rteval: Display core sharing warnings in text report

[John Kacur]

Add XSLT template to display CoreSharingWarnings in the text report
generated with the -Z option. The warnings appear after the "Tuned state"
section and before "System load" in the report output.

The template conditionally displays the "Core Sharing Warnings:" section
only when warnings are present in the XML, keeping the report clean when
there are no core sharing issues detected.

Example output:
   Core Sharing Warnings:
       Warning: Housekeeping CPU 0 (isol) shares core with measurement CPU 8 (isol)
       Warning: Measurement CPU 1 (isol) shares core with load CPU 9 (isol)

This completes the core sharing validation feature by making the warnings
visible in both the XML report and the human-readable text summary.

Assisted-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: John Kacur <jkacur@redhat.com>
---
 rteval/rteval_text.xsl | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/rteval/rteval_text.xsl b/rteval/rteval_text.xsl
index 146302744f58..54dc7d2f9a07 100644
--- a/rteval/rteval_text.xsl
+++ b/rteval/rteval_text.xsl
@@ -160,7 +160,18 @@
         </xsl:otherwise>
     </xsl:choose>
     <xsl:text>&#10;&#10;</xsl:text>
-   
+
+    <!-- Display core sharing warnings if present -->
+    <xsl:if test="SystemInfo/CPUtopology/CoreSharingWarnings/warning">
+      <xsl:text>   Core Sharing Warnings:&#10;</xsl:text>
+      <xsl:for-each select="SystemInfo/CPUtopology/CoreSharingWarnings/warning">
+        <xsl:text>       </xsl:text>
+        <xsl:value-of select="."/>
+        <xsl:text>&#10;</xsl:text>
+      </xsl:for-each>
+      <xsl:text>&#10;</xsl:text>
+    </xsl:if>
+
     <xsl:text>   System load:&#10;</xsl:text>
     <xsl:text>       Load average: </xsl:text>
     <xsl:value-of select="loads/@load_average"/>
-- 
2.53.0

[PATCH 6/7] rteval: Add --warn-non-isolated-core-sharing option for measurement vs load warnings

[John Kacur]

Add a new command-line flag --warn-non-isolated-core-sharing that enables
warnings when measurement and load CPUs share physical cores even when
neither CPU is isolated.

By default, rteval only warns about core sharing when at least one of the
sharing CPUs is isolated (via isolcpus). This is the most critical case
because isolated CPUs are explicitly intended for dedicated workloads, and
sharing cores defeats the isolation.

However, even when CPUs are not isolated, running measurement and load
threads on sibling CPUs sharing a physical core can still impact
measurement accuracy due to shared execution resources (L1/L2 caches,
execution units, TLB, etc.). This new flag allows users to detect this
situation when they want stricter validation.

The flag only affects measurement vs load checking. Housekeeping vs
measurement and housekeeping vs load continue to warn only when at least
one CPU is isolated, as housekeeping tasks are expected to run on
non-isolated CPUs.

Example usage:
  rteval --measurement-cpulist 4 --loads-cpulist 12 \
         --warn-non-isolated-core-sharing

  Warning: Measurement CPU 4 shares core with load CPU 12

Implementation:
- rteval-cmd: Add --warn-non-isolated-core-sharing argument
- systopology.py: Add warn_non_isolated parameter to validate_core_sharing()
- check_pair(): Add check_type parameter to distinguish measurement_vs_load
  from other combinations and apply different warning logic

Assisted-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: John Kacur <jkacur@redhat.com>
---
 rteval-cmd            |  6 +++++-
 rteval/systopology.py | 23 ++++++++++++++++-------
 2 files changed, 21 insertions(+), 8 deletions(-)

diff --git a/rteval-cmd b/rteval-cmd
index b3f9fac2c2cf..3180e1a7857a 100755
--- a/rteval-cmd
+++ b/rteval-cmd
@@ -116,6 +116,9 @@ def parse_options(cfg, parser, cmdargs):
     parser.add_argument("--housekeeping", dest="rteval___housekeeping",
                       type=str, default="", metavar="CPULIST",
                       help="isolated CPUs reserved for system tasks (not used by rteval)")
+    parser.add_argument("--warn-non-isolated-core-sharing", dest="rteval___warn_non_isolated_core_sharing",
+                      action="store_true", default=False,
+                      help="warn about measurement and load CPUs sharing cores even when neither is isolated")
     parser.add_argument("-s", "--sysreport", dest="rteval___sysreport",
                       action="store_true", default=rtevcfg.sysreport,
                       help=f'run sysreport to collect system data (default: {rtevcfg.sysreport})')
@@ -449,7 +452,8 @@ if __name__ == '__main__':
         # Validate core sharing between housekeeping, measurement, and load CPUs
         msrcfg_cpus = CpuList(msrcfg.cpulist).cpus if msrcfg.cpulist else []
         ldcfg_cpus = CpuList(ldcfg.cpulist).cpus if ldcfg.cpulist else []
-        core_warnings = validate_core_sharing(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus)
+        core_warnings = validate_core_sharing(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus,
+                                              cmd_opts.rteval___warn_non_isolated_core_sharing)
         for warning in core_warnings:
             logger.log(Log.WARN, warning)
 
diff --git a/rteval/systopology.py b/rteval/systopology.py
index 0ee81d5c5e36..0e4eb5fe7b89 100644
--- a/rteval/systopology.py
+++ b/rteval/systopology.py
@@ -294,7 +294,7 @@ def parse_cpulist_from_config(cpulist, run_on_isolcpus=False):
     return result
 
 
-def validate_core_sharing(housekeeping_cpus, measurement_cpus, load_cpus):
+def validate_core_sharing(housekeeping_cpus, measurement_cpus, load_cpus, warn_non_isolated=False):
     """
     Check for CPUs sharing physical cores across different workload types.
     Warns if isolated CPUs share cores between housekeeping, measurement, and load groups.
@@ -302,6 +302,7 @@ def validate_core_sharing(housekeeping_cpus, measurement_cpus, load_cpus):
     :param housekeeping_cpus: List of housekeeping CPU integers
     :param measurement_cpus: List of measurement CPU integers
     :param load_cpus: List of load CPU integers
+    :param warn_non_isolated: If True, also warn about measurement vs load sharing even when neither is isolated
     :return: List of warning messages (empty if no issues)
     """
     from rteval.sysinfo.coresiblings import CoreSiblings
@@ -318,14 +319,22 @@ def validate_core_sharing(housekeeping_cpus, measurement_cpus, load_cpus):
         # If we can't read topology, skip validation
         return warnings
 
-    def check_pair(cpu1, cpu2, type1, type2):
+    def check_pair(cpu1, cpu2, type1, type2, check_type):
         """Check if two CPUs share a core and generate warning if at least one is isolated"""
         if cs.share_core(cpu1, cpu2):
             cpu1_isol = cpu1 in isolated_cpus
             cpu2_isol = cpu2 in isolated_cpus
 
-            # Only warn if at least one CPU is isolated
-            if cpu1_isol or cpu2_isol:
+            # Determine if we should warn based on check_type
+            should_warn = False
+            if check_type == "measurement_vs_load" and warn_non_isolated:
+                # For measurement vs load with flag set: warn if neither is isolated
+                should_warn = not cpu1_isol and not cpu2_isol
+            else:
+                # For all other cases: only warn if at least one CPU is isolated
+                should_warn = cpu1_isol or cpu2_isol
+
+            if should_warn:
                 cpu1_str = f"{type1} CPU {cpu1}{' (isol)' if cpu1_isol else ''}"
                 cpu2_str = f"{type2} CPU {cpu2}{' (isol)' if cpu2_isol else ''}"
                 warnings.append(f"Warning: {cpu1_str} shares core with {cpu2_str}")
@@ -334,17 +343,17 @@ def validate_core_sharing(housekeeping_cpus, measurement_cpus, load_cpus):
     # 1. Housekeeping vs Measurement
     for hk_cpu in housekeeping_cpus:
         for msr_cpu in measurement_cpus:
-            check_pair(hk_cpu, msr_cpu, "Housekeeping", "measurement")
+            check_pair(hk_cpu, msr_cpu, "Housekeeping", "measurement", "housekeeping_vs_measurement")
 
     # 2. Housekeeping vs Load
     for hk_cpu in housekeeping_cpus:
         for ld_cpu in load_cpus:
-            check_pair(hk_cpu, ld_cpu, "Housekeeping", "load")
+            check_pair(hk_cpu, ld_cpu, "Housekeeping", "load", "housekeeping_vs_load")
 
     # 3. Measurement vs Load
     for msr_cpu in measurement_cpus:
         for ld_cpu in load_cpus:
-            check_pair(msr_cpu, ld_cpu, "Measurement", "load")
+            check_pair(msr_cpu, ld_cpu, "Measurement", "load", "measurement_vs_load")
 
     return warnings
 
-- 
2.53.0

[PATCH 7/7] rteval: Include --warn-non-isolated-core-sharing warnings in XML report

[John Kacur]

Extend the add_core_sharing_warnings() method to accept the warn_non_isolated
parameter and pass it through to validate_core_sharing(). This ensures that
warnings generated by the --warn-non-isolated-core-sharing flag are included
in the XML report's CoreSharingWarnings section.

Previously, the flag only affected console warnings. Now the warnings are
also preserved in the XML report and will appear in text reports generated
with -Z option, since the XSLT stylesheet already displays any warnings
found in the CoreSharingWarnings section.

Changes:
- rteval/sysinfo/cputopology.py: Add warn_non_isolated parameter to
  add_core_sharing_warnings() and pass it to validate_core_sharing()
- rteval-cmd: Pass cmd_opts.rteval___warn_non_isolated_core_sharing to
  add_core_sharing_warnings() when adding warnings to XML

This completes the --warn-non-isolated-core-sharing feature by ensuring
warnings appear in console output, XML reports, and text summaries.

Assisted-by: Claude Sonnet 4.5 <noreply@anthropic.com>
Signed-off-by: John Kacur <jkacur@redhat.com>
---
 rteval-cmd                    | 3 ++-
 rteval/sysinfo/cputopology.py | 6 ++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/rteval-cmd b/rteval-cmd
index 3180e1a7857a..f730d3177290 100755
--- a/rteval-cmd
+++ b/rteval-cmd
@@ -494,7 +494,8 @@ if __name__ == '__main__':
         rteval = RtEval(config, loadmods, measuremods, logger)
 
         # Add core sharing warnings to the XML report now that CPU lists are finalized
-        rteval._sysinfo.add_core_sharing_warnings(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus)
+        rteval._sysinfo.add_core_sharing_warnings(housekeeping_cpus, msrcfg_cpus, ldcfg_cpus,
+                                                  cmd_opts.rteval___warn_non_isolated_core_sharing)
 
         rteval.Prepare(rtevcfg.onlyload)
 
diff --git a/rteval/sysinfo/cputopology.py b/rteval/sysinfo/cputopology.py
index a21c19179f28..f650eca8db8d 100644
--- a/rteval/sysinfo/cputopology.py
+++ b/rteval/sysinfo/cputopology.py
@@ -94,7 +94,7 @@ class CPUtopology:
         return self.__cputop_n
 
 
-    def add_core_sharing_warnings(self, housekeeping_cpus, measurement_cpus, load_cpus):
+    def add_core_sharing_warnings(self, housekeeping_cpus, measurement_cpus, load_cpus, warn_non_isolated=False):
         """
         Add core sharing warnings to the CPUtopology XML node.
         Should be called after CPU lists are finalized.
@@ -102,6 +102,7 @@ class CPUtopology:
         :param housekeeping_cpus: List of housekeeping CPU integers
         :param measurement_cpus: List of measurement CPU integers
         :param load_cpus: List of load CPU integers
+        :param warn_non_isolated: If True, also warn about measurement vs load sharing even when neither is isolated
         """
         if self.__cputop_n is None:
             return
@@ -118,7 +119,8 @@ class CPUtopology:
         warnings = validate_core_sharing(
             housekeeping_cpus or [],
             measurement_cpus or [],
-            load_cpus or []
+            load_cpus or [],
+            warn_non_isolated
         )
 
         # Add warnings to XML if any were found
-- 
2.53.0