* [PATCH 1/7] rteval: Add CoreSiblings class for CPU core topology queries
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
@ 2026-04-21 18:26 ` John Kacur
2026-04-21 18:26 ` [PATCH 2/7] rteval: Add core sharing validation for CPU isolation John Kacur
` (5 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 2/7] rteval: Add core sharing validation for CPU isolation
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
2026-04-21 18:26 ` [PATCH 1/7] rteval: Add CoreSiblings class for CPU core topology queries John Kacur
@ 2026-04-21 18:26 ` John Kacur
2026-04-21 18:26 ` [PATCH 3/7] rteval: Include core sharing warnings in XML report John Kacur
` (4 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 3/7] rteval: Include core sharing warnings in XML report
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
2026-04-21 18:26 ` [PATCH 1/7] rteval: Add CoreSiblings class for CPU core topology queries John Kacur
2026-04-21 18:26 ` [PATCH 2/7] rteval: Add core sharing validation for CPU isolation John Kacur
@ 2026-04-21 18:26 ` John Kacur
2026-04-21 18:26 ` [PATCH 4/7] rteval: Add temporary test for core sharing validation with mocked isolated CPUs John Kacur
` (3 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 4/7] rteval: Add temporary test for core sharing validation with mocked isolated CPUs
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
` (2 preceding siblings ...)
2026-04-21 18:26 ` [PATCH 3/7] rteval: Include core sharing warnings in XML report John Kacur
@ 2026-04-21 18:26 ` John Kacur
2026-04-21 18:26 ` [PATCH 5/7] rteval: Display core sharing warnings in text report John Kacur
` (2 subsequent siblings)
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 5/7] rteval: Display core sharing warnings in text report
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
` (3 preceding siblings ...)
2026-04-21 18:26 ` [PATCH 4/7] rteval: Add temporary test for core sharing validation with mocked isolated CPUs John Kacur
@ 2026-04-21 18:26 ` John Kacur
2026-04-21 18:26 ` [PATCH 6/7] rteval: Add --warn-non-isolated-core-sharing option for measurement vs load warnings John Kacur
2026-04-21 18:26 ` [PATCH 7/7] rteval: Include --warn-non-isolated-core-sharing warnings in XML report John Kacur
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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> </xsl:text>
-
+
+ <!-- Display core sharing warnings if present -->
+ <xsl:if test="SystemInfo/CPUtopology/CoreSharingWarnings/warning">
+ <xsl:text> Core Sharing Warnings: </xsl:text>
+ <xsl:for-each select="SystemInfo/CPUtopology/CoreSharingWarnings/warning">
+ <xsl:text> </xsl:text>
+ <xsl:value-of select="."/>
+ <xsl:text> </xsl:text>
+ </xsl:for-each>
+ <xsl:text> </xsl:text>
+ </xsl:if>
+
<xsl:text> System load: </xsl:text>
<xsl:text> Load average: </xsl:text>
<xsl:value-of select="loads/@load_average"/>
--
2.53.0
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 6/7] rteval: Add --warn-non-isolated-core-sharing option for measurement vs load warnings
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
` (4 preceding siblings ...)
2026-04-21 18:26 ` [PATCH 5/7] rteval: Display core sharing warnings in text report John Kacur
@ 2026-04-21 18:26 ` John Kacur
2026-04-21 18:26 ` [PATCH 7/7] rteval: Include --warn-non-isolated-core-sharing warnings in XML report John Kacur
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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
^ permalink raw reply related [flat|nested] 8+ messages in thread* [PATCH 7/7] rteval: Include --warn-non-isolated-core-sharing warnings in XML report
2026-04-21 18:26 [PATCH 0/7] Core sharing validation for CPU isolation John Kacur
` (5 preceding siblings ...)
2026-04-21 18:26 ` [PATCH 6/7] rteval: Add --warn-non-isolated-core-sharing option for measurement vs load warnings John Kacur
@ 2026-04-21 18:26 ` John Kacur
6 siblings, 0 replies; 8+ messages in thread
From: John Kacur @ 2026-04-21 18:26 UTC (permalink / raw)
To: linux-rt-users; +Cc: Clark Williams, Tomas Glozar
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
^ permalink raw reply related [flat|nested] 8+ messages in thread