def _initialize(self) -> Optional[int]: """Check privileges, RDT availability and prepare internal state. Can return error code that should stop Runner. """ if not security.are_privileges_sufficient(): log.error( "Insufficient privileges! " "Impossible to use perf_event_open/resctrl subsystems. " "For unprivileged user it is needed to: " "adjust /proc/sys/kernel/perf_event_paranoid (set to -1), " "has CAP_DAC_OVERRIDE and CAP_SETUID capabilities and" "SECBIT_NO_SETUID_FIXUP secure bit set.") return 1 # Initialization (auto discovery Intel RDT features). rdt_available = resctrl.check_resctrl() if self._rdt_enabled is None: self._rdt_enabled = rdt_available log.info('RDT enabled (auto configuration): %s', self._rdt_enabled) elif self._rdt_enabled is True and not rdt_available: log.error('RDT explicitly enabled but not available - exiting!') return 1 if self._rdt_enabled: # Resctrl is enabled and available, call a placeholder to allow further initialization. rdt_initialization_ok = self._initialize_rdt() if not rdt_initialization_ok: return 1 # Postpone the container manager initialization after rdt checks were performed. platform_cpus, _, platform_sockets = platforms.collect_topology_information( ) platform, _, _ = platforms.collect_platform_information( self._rdt_enabled) rdt_information = platform.rdt_information self._event_names = _filter_out_event_names_for_cpu( self._event_names, platform.cpu_codename) # We currently do not support RDT without monitoring. if self._rdt_enabled and not rdt_information.is_monitoring_enabled(): log.error('RDT monitoring is required - please enable CAT ' 'or MBM with kernel parameters!') return 1 self._containers_manager = ContainerManager( platform=platform, allocation_configuration=self._allocation_configuration, event_names=self._event_names, enable_derived_metrics=self._enable_derived_metrics, ) return None
def _initialize(self) -> Optional[int]: """Check RDT availability, privileges and prepare internal state. Can return error code that should stop Runner. """ # Initialization (auto discovery Intel RDT features). rdt_available = resctrl.check_resctrl() if self._rdt_enabled is None: self._rdt_enabled = rdt_available log.info('RDT enabled (auto configuration): %s', self._rdt_enabled) elif self._rdt_enabled is True and not rdt_available: log.error('RDT explicitly enabled but not available - exiting!') return 1 # _allocation_configuration is set in allocation mode (AllocationRunner) # so we need access to write in cgroups. write_to_cgroup = self._allocation_configuration is not None use_resctrl = self._rdt_enabled use_perf = len(self._event_names) > 0 if not security.are_privileges_sufficient(write_to_cgroup, use_resctrl, use_perf): return 1 if self._rdt_enabled: # Resctrl is enabled and available, call a placeholder to allow further initialization. # For MeasurementRunner it's nothing to configure in RDT to measure resource usage. # Check if it's needed to specific rdt initialization in case # of using MeasurementRunner functionality in other runner. if self._initialize_rdt_callback is not None: rdt_initialization_ok = self._initialize_rdt_callback() if not rdt_initialization_ok: return 1 log.debug('rdt_enabled: %s', self._rdt_enabled) log.debug('gather_hw_mm_topology: %s', self._gather_hw_mm_topology) platform, _, _ = platforms.collect_platform_information( self._rdt_enabled, gather_hw_mm_topology=self._gather_hw_mm_topology ) rdt_information = platform.rdt_information self._event_names = _filter_out_event_names_for_cpu( self._event_names, platform.cpu_codename) # We currently do not support RDT without monitoring. if self._rdt_enabled and not rdt_information.is_monitoring_enabled(): log.error('RDT monitoring is required - please enable CAT ' 'or MBM with kernel parameters!') return 1 self._containers_manager = ContainerManager( platform=platform, allocation_configuration=self._allocation_configuration, event_names=self._event_names, enable_derived_metrics=self._enable_derived_metrics, wss_reset_interval=self._wss_reset_interval, perf_aggregate_cpus=self._perf_aggregate_cpus ) self._init_uncore_pmu(self._enable_derived_metrics, self._enable_perf_uncore, platform) return None
def test_check_resctrl(*mock): assert check_resctrl()
def _initialize(self) -> Optional[int]: """Check RDT availability, privileges and prepare internal state. Can return error code that should stop Runner. Flow: - Conclude requirements based on configuration - Conclude required features based on auto discovery - confront user expectations from configuration file with resctrl fs and security access - check RDT HW monitoring features availability """ resctrl_available = resctrl.check_resctrl() # If enabled explicitly check resctrl availability right now. if self._rdt_enabled is True and not resctrl_available: log.error('RDT explicitly enabled but resctrl fs not available - exiting!') return 1 # Auto discovery Intel RDT features. if self._rdt_enabled is None: # Assume yes temporary - but will check monitoring/access later. log.debug('Enable RDT auto discovery (resctrl availability=%s)', resctrl_available) self._rdt_enabled = resctrl_available rdt_auto_enabling = True else: rdt_auto_enabling = False log.debug('gather_hw_mm_topology: %s', self._gather_hw_mm_topology) platform, _, _ = platforms.collect_platform_information( resctrl_available, gather_hw_mm_topology=self._gather_hw_mm_topology ) # Confront RDT (resctrl fs) with HW enabled monitoring features. if self._rdt_enabled and not platform.rdt_information.is_monitoring_enabled(): # Note: WCA does not support RDT without monitoring (keeps a mapping of # cgroups and resctrl groups). msg = ('Resctrl is available but RDT monitoring features are not!' + 'Please enable CMT or MBM with kernel parameters (monitoring is ' + 'required for CAT or MBA allocation)!') if rdt_auto_enabling: log.debug(msg) self._rdt_enabled = False platform.rdt_information = None # override rdt information should not be available later # e.g. ContainerManager else: # If RDT was force fail short here. log.error(msg) return 1 # All RDT checks (security/check) done - show info and call initialization callback. log.info('RDT: %s %s', 'enabled' if self._rdt_enabled else 'disabled', ' (auto discovery)' if rdt_auto_enabling else '', ) # Event names (perf cgroups) self._event_names = filter_out_event_names_for_cpu( self._event_names, platform.cpu_codename) log.info('Enabling %i perf events (for cgroups).', len(self._event_names)) log.debug('Enabling perf events: %s', ', '.join(self._event_names)) # Check and assume most popular number of available number of HW counters. if self._event_names: if not check_perf_event_count_limit(self._event_names, platform.cpus, platform.cores): return 1 # _allocation_configuration is set in allocation mode (AllocationRunner) # so we need access to write in cgroups. write_to_cgroup = self._allocation_configuration is not None use_perf = len(self._event_names) > 0 # Check we have enough access. if not security.are_privileges_sufficient(write_to_cgroup, self._rdt_enabled, use_perf): return 1 # Resctrl is enabled and available, call a placeholder to allow further initialization. # For "measurement mode" it's nothing to configure in RDT. # Check if it's needed to specific rdt initialization in case # of using "MeasurementRunner" as component functionality in other runners e.g. Allocation. if self._rdt_enabled: if self._initialize_rdt_callback is not None: rdt_initialization_ok = self._initialize_rdt_callback() if not rdt_initialization_ok: return 1 self._containers_manager = ContainerManager( platform=platform, allocation_configuration=self._allocation_configuration, event_names=self._event_names, enable_derived_metrics=self._enable_derived_metrics, wss_reset_cycles=self._wss_reset_cycles, wss_stable_cycles=self._wss_stable_cycles, wss_membw_threshold=self._wss_membw_threshold, perf_aggregate_cpus=self._perf_aggregate_cpus, interval=self._interval, sched=self._sched, ) log.log(TRACE, 'container manager config: %s', self._containers_manager.__dict__) self._init_uncore_pmu_events(self._enable_derived_metrics, self._uncore_events, platform) return None