Core-Specific Metrics Collection in Multi-Core Processors
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current methods for collecting core-specific metrics in multi-core processors are resource-intensive, limiting sampling frequency to several seconds, which is insufficient for generating actionable insights to meet quality of service (QoS) requirements, especially in live field deployments where dynamic effects like load changes and noisy neighbors occur, and often result in high resource consumption and latency.
Innovation Solution
A collector application that fetches core-specific metrics in the kernel space based on context switching triggered by task requests, processes them in user space, and publishes results at regular intervals, using lockless buffers and shared memory to minimize resource usage and latency, allowing for higher sampling frequencies without impacting QoS.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Measurement precision
If current collectors are used to fetch core-specific metrics, then metrics can be collected, but resource consumption increases and sampling frequency is limited to several seconds
Solution Approach 1:
The patent divides the metric collection process into separate collector applications for each core, where each collector runs independently in kernel space. This segmentation allows parallel collection of metrics from multiple cores without mutual interference, enabling higher sampling frequencies while distributing resource consumption across multiple lightweight processes rather than a single resource-intensive collector
Solution Approach 2:
The patent introduces shared memory buffers as an intermediary mechanism between the kernel-space collectors and user-space processing. Metrics are pushed to these buffers by collectors and retrieved by user-space applications without direct interaction, eliminating the need for complex inter-process communication and reducing overhead. This intermediary approach enables efficient high-frequency sampling by decoupling the collection and processing operations
2Productivity
If sampling frequency is increased to generate actionable insights, then QoS requirements can be met, but resource consumption and latency increase
Solution Approach 1:
The patent implements preliminary action by having collectors in kernel space continuously fetch and push metrics to shared memory buffers before user-space applications need them. This pre-positioning of data in accessible buffers eliminates wait times and reduces latency when user-space applications need to process metrics for generating actionable insights, enabling high sampling frequencies without proportional increases in overall system latency
Solution Approach 2:
The patent ensures continuous metric collection and availability by running multiple kernel-space collectors simultaneously, each continuously fetching metrics from its associated core and pushing them to shared buffers. This continuous operation without interruption or batching ensures that actionable insights can be generated immediately when needed, maintaining high productivity while minimizing latency through uninterrupted data flow
3Ease of operation
If fixed interval sampling is used, then implementation is simple, but collectors become primary workloads impacting QoS requirements
Solution Approach 1:
The patent implements dynamic, event-driven sampling where collectors are triggered by scheduler events rather than fixed intervals. Each collector monitors for specific events (such as task scheduling decisions) and collects metrics only when these events occur. This dynamic approach maintains implementation simplicity through event-driven programming while significantly reducing resource consumption compared to continuous fixed-interval sampling, thereby preserving QoS requirements for workload execution
Data Source
Figure 1
Figure 2
Figure 3
AI summary
Examples include techniques for core-specific metrics collection. Examples include fetching metrics of a core of a multi-core processor from one or more registers responsive to scheduling of an event. The fetched metrics are pushed to a shared memory space of a memory that is accessible to a user-space application and accessible to other cores of the multi-core processor. The user-space application to access the shared memory space to aggregate core-specific metrics associated with at least the core of the multi-core processor and then publish the aggregated core-specific metrics.