A high-precision parallel system call detection architecture and method

Abstract

This invention proposes a high-precision parallel system call detection architecture and method. By employing techniques such as system call generation, allocation, CPU core allocation, and high-precision timers, it aims to overcome the limitations of existing technologies, thereby improving the accuracy and efficiency of detection and ensuring that concurrency issues can be comprehensively and stably detected and reproduced.

Description

Technical Field

[0001] This invention belongs to the field of software testing technology, specifically relating to a high-precision parallel system call detection architecture and method. Background Technology

[0002] Currently, computer system hardware architecture is constantly evolving, and multi-core processors have become the mainstream configuration. Multi-core processors enable computers to execute multiple threads or processes simultaneously, greatly improving system processing power and operating efficiency. However, with the widespread application of multi-core technology, concurrency issues have become increasingly prominent, becoming a significant factor affecting system stability and reliability.

[0003] In multi-core systems, multiple threads or processes can access and manipulate shared resources simultaneously. Due to the lack of effective coordination and management mechanisms, concurrency issues such as data inconsistency, race conditions, and deadlocks can easily arise. Although concurrency issues have received widespread attention in the industry, there is currently no systematic approach to uniformly solve these problems.

[0004] Furthermore, the continuous improvement in the performance of modern computer systems means that the time a system spends in the critical section that could trigger concurrency issues is extremely short. This results in a low probability of concurrency problems occurring during actual operation, making them difficult to accurately reproduce and detect. Most existing operating system testing frameworks can only generate a single system call sequence, failing to fully simulate concurrent scenarios in a multi-core environment and thus making it difficult to effectively discover potential concurrency issues.

[0005] Therefore, how to accurately detect and resolve concurrency issues in a multi-core environment has become a critical problem that urgently needs to be solved in the field of computer systems.

[0006] In view of this, the present invention is hereby proposed. Summary of the Invention

[0007] The purpose of this invention is to overcome the shortcomings of the prior art and provide a high-precision parallel system call detection architecture and method. By using technologies such as system call generation, allocation, CPU core allocation, and high-precision timers, this invention aims to solve the limitations of the prior art, thereby improving the accuracy and efficiency of detection and ensuring that concurrency problems can be detected and reproduced comprehensively and stably.

[0008] To achieve the above objectives, the present invention provides the following technical solution: According to a first aspect of the present invention, a high-precision parallel system call detection architecture is provided, comprising: a system call generation module, a system call allocation module, a CPU core allocation module, a high-precision timer module, a concurrent execution module, and a concurrent data conflict detection module; The system call generation module is used to model the correlation of system calls and generate multiple system call sequences that are independent of each other. The system call allocation module is used to allocate multiple system call sequences to different threads, with each thread bound to one system call sequence, and to ensure that system call sequences with data correlation are allocated to different threads; The CPU core allocation module is used to bind the thread to different physical CPU cores and ensure that the thread has exclusive access to the physical CPU core through a priority mechanism. A high-precision timer module is used to set a unified trigger time. When the trigger time is reached, all threads are triggered simultaneously via a signal or callback function. The concurrent execution module is used to enable each thread to concurrently execute the allocated system call sequence on its own dedicated physical CPU core at the triggering time. The concurrent data conflict detection module is used to monitor the execution results and resource status of system calls, detect concurrency issues, and record error information.

[0009] According to a second aspect of the present invention, a high-precision parallel system call detection method is proposed, which employs a high-precision parallel system call detection architecture and includes the following steps: Step S1: System call sequence generation: The system call generation module performs correlation analysis on the system calls in the program to be detected or the target application, performs correlation modeling based on the data dependency and control dependency relationship between system calls, divides the system calls with correlation into the same group, and generates multiple system call sequences that are data independent of each other. Step S2, System call sequence allocation: The system call allocation module distributes the multiple system call sequences generated in step S1 to different threads according to a preset load balancing strategy. Each thread is bound to one and only one system call sequence, and ensures that system calls with data correlation are allocated to different threads to avoid resource contention within threads masking potential concurrency issues. Step S3, CPU Core Binding and Exclusivity: The CPU core allocation module binds the threads created in step S2 to different physical CPU cores through the affinity setting interface provided by the operating system; and by setting the thread priority to real-time priority, combined with the CPU core isolation mechanism or exclusive strategy, it ensures that each thread is not preempted by other unrelated processes or threads when running on its bound CPU core, thereby achieving true isolation and exclusive use of CPU resources. Step S4, Setting the Synchronization Trigger Time: The high-precision timer module sets a unified future trigger time, which is based on a high-precision clock source and uses an adaptive waiting mechanism that combines busy waiting and blocking waiting to eliminate the scheduling delay of the operating system and ensure that all threads are woken up or receive the trigger signal at the trigger time. Step S5, concurrent execution: When the triggering time is reached, the high-precision timer module triggers all threads to start executing their respective bound system call sequences simultaneously through cross-thread synchronization signals or callback functions; each thread executes system calls concurrently on its dedicated physical CPU core, achieving true parallel system calls; Step S6, Concurrency Conflict Detection: During the execution of step S5, the concurrent data conflict detection module uses a vector clock or happens-before relationship tracking algorithm to record the timing relationship between system calls in different threads, in order to accurately locate the point of occurrence of data competition.

[0010] In one possible embodiment, in step S1, the correlation modeling specifically includes: taking each system call captured during program execution as a node in a graph, and forming directed edges between nodes due to data dependencies (e.g., shared memory or file descriptor read / write transfer) or control dependencies (e.g., the execution order of system calls, conditional branches, or the influence of synchronization primitives); subsequently, the directed graph is processed using graph partitioning algorithms such as Tarjan's algorithm or Kosaraju's algorithm to extract multiple strongly connected components (SCCs), and further obtained mutually independent subgraphs through weakly connected component analysis, with each independent subgraph corresponding to an independent system call sequence.

[0011] In one possible embodiment, step S2, specifically ensuring that system calls with data dependencies are assigned to different threads, includes: Based on the result of subgraph partitioning of the directed graph in step S1, system calls are refined into independent subgraphs and transformed into thread functions for concurrent execution. This is determined by the size and scale of the independent subgraphs. Each thread function corresponds to a subgraph, and each subgraph corresponds to a system call sequence.

[0012] In one possible embodiment, step S3, the exclusive use strategy for the CPU core includes: binding a specific thread to one or more designated logical CPU cores by setting a CPU affinity mask for the thread; simultaneously, combining the isolcpus startup parameters provided by the Linux kernel, completely isolating the designated CPU core from the general process scheduler, so that only the bound thread is allowed to run on the core, thereby achieving exclusive use of the CPU core. Under this mechanism, process / thread migration caused by inter-processor interrupts (IPI), timer interrupts, or other kernel scheduling events is avoided, effectively eliminating context switching overhead and cache pollution, and significantly improving the deterministic and real-time performance of thread execution.

[0013] In one possible embodiment, in step S4, the adaptive waiting mechanism specifically involves: all threads first synchronizing to a common reference time point using cross-thread synchronization primitives; subsequently, each thread enters a short-term, precise busy-waiting loop. In the final stage of the busy-waiting, the thread voluntarily relinquishes the CPU and blocks on a high-precision timer; the high-precision timer simultaneously sends a wake-up signal to all threads at a preset trigger time, thereby precisely waking up all threads and enabling them to simultaneously begin execution from the start of their respective bound system call sequences. This adaptive waiting mechanism, through the dynamic combination of busy waiting and blocking waiting, effectively reduces wake-up latency and avoids prolonged CPU resource occupation, achieving a good balance between CPU utilization and triggering precision.

[0014] In one possible embodiment, in step S5, the high-precision timer generates a synchronization signal at a preset trigger time; after all threads receive the synchronization signal, they simultaneously start execution from the starting position of their respective bound independent system call sequences; each thread issues system calls in sequence according to the system call sequence corresponding to the subgraph, and coordinates between threads through synchronization primitives at the sequence synchronization point, thereby achieving high-precision concurrent execution of multiple threads.

[0015] In one possible embodiment, in step S6, the concurrent data conflict detection module uses a vector clock or happens-before relationship tracking algorithm to record the timing relationship of system calls during multi-threaded execution.

[0016] The Vector Clock algorithm's specific detection process is as follows: A vector clock is maintained for each thread, where each component of the vector clock corresponds to a thread's logical timestamp. During system call execution, the vector clocks of each thread are dynamically updated according to the program order and thread synchronization relationships (e.g., lock acquisition / release, barriers, semaphores, and other synchronization primitives). When any thread accesses shared memory for reading or writing, the vector clock of the current access is compared with the vector clock recorded from the previous access to that memory location. If the two vector clocks do not satisfy the happens-before relationship (i.e., one clock is not completely less than or equal to the other), and at least one access is a write operation, a data conflict (data race) is determined to have occurred, and the system call point and its associated thread are accurately located. This mechanism can accurately capture data races caused by timing discrepancies in the happens-before relationship during concurrent execution, achieving real-time or offline accurate detection of potential data conflicts.

[0017] The happens-before relationship tracing algorithm works as follows: A vector clock is maintained for each thread. During system call execution, the vector clock is dynamically updated according to the program order and thread synchronization relationships. When a thread reads or writes to shared memory, the vector clock of the current access is compared with the vector clock recorded from the last access to that memory location. If the two vector clocks do not satisfy the happens-before relationship (i.e., one is not completely ahead of the other), and there is at least one write operation, a data conflict is determined. The recorded vector clocks directly locate the two conflicting system calls and their respective threads, thus achieving precise location of data contention.

[0018] According to a third aspect of the present invention, an electronic device is also provided, including a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor executes the program to implement the method described in any of the preceding claims.

[0019] According to a fourth aspect of the present invention, a computer-readable storage medium is also provided, on which a computer program is stored, which, when executed by a processor, implements the method described in any of the preceding claims.

[0020] Compared with the prior art, the technical solution provided by the present invention has the following beneficial effects: The high-precision parallel system call detection method proposed in this invention significantly improves the reproducibility of concurrency problems through deep optimization of the system call execution mechanism in a multi-core environment. Traditional techniques rely on pseudo-parallel execution using single-core or time-sharing scheduling, resulting in extremely short critical section times and unstable triggering conditions. In contrast, this invention, through data dependency modeling, forces related system calls operating on the same resource to be allocated to different threads and uses a high-precision timer to achieve synchronous triggering. This allows critical operations to be executed in parallel at almost the same time, significantly extending the critical section time during which the system can trigger problems, and making previously difficult-to-detect conflicts such as race conditions and data inconsistencies more easily exposed.

[0021] In simulating a real multi-core parallel environment, this method breaks through the scheduling limitations of traditional testing frameworks. By fixing threads to independent CPU cores and setting real-time priorities, it ensures that threads exclusively occupy core resources during the testing process, avoiding the "pseudo-parallelism" problem caused by context switching or core migration, and realizing a hardware-level real concurrent execution environment. This precise control over underlying hardware resources enables the testing process to cover complex scenarios such as cross-core resource contention and cache consistency, providing a reliable guarantee for the authenticity verification of concurrency issues.

[0022] This invention also constructs a systematic concurrency detection framework, solving the long-standing problem of fragmented detection in the industry. Through standardized system call correlation modeling, multi-threaded sequence generation, and core allocation strategies, concurrency detection is transformed from a randomized "luck-based" mode to a goal-oriented scenario construction, forming a complete closed loop from environment configuration and operation execution to conflict detection. This framework is platform-independent and can be quickly adapted to different scenarios such as operating system kernels and distributed systems by adjusting system call types and parameters, possessing broad technical reusability and engineering scalability.

[0023] In terms of detection efficiency and cost, this method demonstrates significant advantages. The proactively constructed high-probability triggering environment allows concurrency issues that would otherwise require tens of thousands of runs to reproduce to only a few hundred tests, improving detection efficiency by several times. Simultaneously, by combining core binding and synchronous logging, it can accurately correlate thread trajectories, system call sequences, and hardware states at the time of conflict occurrence, significantly reducing the need to locate and fix underlying defects and effectively lowering the time and manpower required for R&D and testing.

[0024] This invention is the first to propose a data-dependent parallel modeling principle and a high-precision synchronization triggering mechanism, filling a gap in the industry's systematic solutions. Its technical approach not only provides a novel approach to stability testing of multi-core systems, but also, through deep utilization of hardware parallelism, promotes the transformation of concurrency problem detection from "uncontrollable verification" to "designable triggering." This has significant technical and engineering value for ensuring the reliability of modern multi-core computer systems and improving the concurrency security of complex software. Attached Figure Description The accompanying drawings are incorporated in and form part of this specification, and together with the description serve to explain the principles of the invention.

[0025] To more clearly illustrate the technical solutions in the embodiments of the present invention or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, for those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0026] Figure 1 This is a schematic diagram of a high-precision parallel system call detection architecture according to the present invention; Figure 2 This is a flowchart of a high-precision parallel system call detection method according to the present invention. Detailed Implementation

[0027] Exemplary embodiments will now be described in detail, examples of which are illustrated in the accompanying drawings. When the following description relates to the drawings, unless otherwise indicated, the same numbers in different drawings denote the same or similar elements. The embodiments described in the following exemplary embodiments do not represent all embodiments consistent with the present invention. Rather, they are merely examples consistent with some aspects of the invention as detailed in the appended claims.

[0028] To enable those skilled in the art to better understand the technical solutions of the present invention, the present invention will be further described in detail below with reference to the accompanying drawings and embodiments.

[0029] Example 1 like Figure 1 As shown, a high-precision parallel system call detection architecture includes: a system call generation module, a system call allocation module, a CPU core allocation module, a high-precision timer module, a concurrent execution module, and a concurrent data conflict detection module. The system call generation module is used to model the correlation of system calls and generate multiple independent system call sequences for the same target resource (such as the same file, the same database record, or the same kernel object).

[0030] The system call allocation module is used to allocate multiple system call sequences to different threads, with each thread bound to one or a group of system call sequences, and to ensure that system call sequences with data correlation (e.g., read-write sequences for the same file) are allocated to different threads to construct potential concurrency race conditions.

[0031] The CPU core allocation module is used to bind each execution thread to a different physical CPU core, and ensure that the thread has exclusive access to the corresponding physical CPU core through priority settings and affinity mechanisms, thereby minimizing thread migration and scheduler interference and simulating parallel execution scenarios in a real multi-core processor environment.

[0032] A high-precision timer module is used to set a unified trigger time. When the preset trigger time is reached, all related threads are triggered simultaneously through a signal or callback function to achieve high-precision cross-thread synchronous startup. The concurrent execution module is used to enable each thread to concurrently execute the allocated system call sequence on its own dedicated physical CPU core at the unified triggering time, thereby accurately constructing the race window in a multi-core environment. The concurrent data conflict detection module is used to monitor the integrity and consistency of file data or kernel resources and the results of system call execution in real time during system call execution, detect concurrent conflicts and record detailed error information.

[0033] This invention achieves precise control over concurrent system calls in a multi-core environment through innovative designs such as system call correlation modeling, high-precision cross-thread synchronization triggering, and CPU core exclusive execution. It overcomes the technical difficulty of hitting the concurrent window in traditional random stress testing, greatly improves the detection coverage and reproducibility of concurrent conflicts, and has high engineering practical value.

[0034] Example 2 like Figure 2 As shown, this invention provides a high-precision parallel system call detection method, which employs a high-precision parallel system call detection architecture and includes the following steps: 1. Test environment setup and target determination First, a Linux operating system environment is set up on a multi-core processor hardware platform (such as a server equipped with 64 or more processors), a test framework that supports multi-threaded parallel execution is configured, and concurrent read and write operations on the same file are determined as the main test target.

[0035] This method can be applied to the detection and reproduction of concurrency conflicts in operating system file systems (such as ext4, Btrfs, XFS), database storage engines, high-concurrency server applications, and kernel driver modules.

[0036] 2. System call generation System calls are modeled for dependencies. Operations such as open, write, pwrite, read, pread, fsync, and close for the same file are defined as related system calls, and independent write operation sequences and read operation sequences are generated and bound to different threads respectively.

[0037] The system call sequence is defined using a system call description language. For example, a write operation sequence containing openat→write→pwrite→fsync→close and a read operation sequence containing openat→pread→read→close are generated. A fuzzing engine combined with mutation strategies (including bit flipping, havoc, splice, etc.) is used to dynamically generate diverse system call sequences, ensuring that the sequences contain explicit offsets and data patterns for subsequent consistency verification.

[0038] 3. System call allocation The generated write operation sequence and read operation sequence are assigned to different execution threads or processes.

[0039] Multiple execution entities are created using multi-process / multi-threaded execution mechanisms or the POSIX thread library, binding write operation sequences to write thread groups and read operation sequences to read thread groups to achieve separate execution of read and write operations. Furthermore, this can be combined with a parallel fuzzing mode (Master-Slave architecture) to further expand the test input space.

[0040] 4. CPU core allocation Each execution thread is bound to a different CPU core to reduce thread migration and scheduling interference.

[0041] By using the sched_setaffinity system call provided by the Linux kernel or the taskset / numactl tools, write thread groups are bound to a subset of CPU cores, and read thread groups are bound to another subset of CPU cores. By setting a real-time scheduling policy (SCHED_FIFO) or adjusting priorities, it is ensured that each thread runs stably on the designated CPU cores, simulating a real multi-core parallel environment to the greatest extent possible.

[0042] 5. High-precision timer trigger By using a high-precision timer to set a unified trigger time, all threads can execute the target system call synchronously at the preset time.

[0043] This system utilizes `clock_nanosleep` (or `CLOCK_MONOTONIC`) or `timerfd` in conjunction with the `epoll` mechanism to achieve nanosecond-level precision synchronous triggering. After all threads start, they enter a synchronization barrier. When the high-precision timer reaches the preset trigger time, they simultaneously initiate the target system call (e.g., executing `pwrite` and `pread` operations concurrently), thus precisely constructing a contention window in a multi-core environment. Furthermore, by dynamically adjusting the trigger time offset, the search for sensitive time windows can be achieved.

[0044] 6. Concurrent execution of system calls Each thread concurrently executes the allocated system call sequence at a unified trigger time.

[0045] 7. Concurrent data conflict detection During system call execution, the integrity and consistency of file data, as well as the system call execution results, are monitored in real time.

[0046] The system verifies the consistency between the read data and the expected written data through data comparison (such as memory comparison or hash verification); it also detects abnormal file sizes, data tearing (tort write), phantom reads, and monitors abnormal information in system call return values ​​and kernel logs.

[0047] When data inconsistency, file corruption, or abnormal operation is detected, it is determined to be a concurrent conflict, and the following information is recorded: the system call sequence corresponding to the conflict, thread identifier, CPU core binding information, precise timestamp, and file data snapshots before and after the conflict.

[0048] If no conflict is detected, the detection parameters (including trigger time offset, operation timing interval, number of threads, system call order, etc.) are dynamically adjusted, and the fuzzing tool continues to generate new system call sequences and repeat the above process until the potential concurrent conflict is successfully reproduced.

[0049] This invention combines system call generation and mutation, coverage guidance mechanism and high-precision timing synchronization technology to achieve precise control of concurrent system calls in a multi-core environment. It significantly improves the detection probability and reproducibility of concurrent conflicts in components such as file systems and storage engines, and provides an efficient and reliable verification method for locating and repairing race conditions in operating system kernels and high-concurrency applications.

[0050] The above description is merely a specific embodiment of the present invention, enabling those skilled in the art to understand or implement the invention. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein can be implemented in other embodiments without departing from the spirit or scope of the invention, exhibiting good scalability and practicality.

[0051] It should be understood that the present invention is not limited to the content already described above, and various modifications and changes can be made without departing from its scope. The scope of the present invention is limited only by the appended claims.

Claims

1. A high-precision parallel system call detection architecture, characterized in that, include: The system call generation module is used to model the correlation of system calls and generate multiple system call sequences that are independent of each other. The system call allocation module is used to allocate the multiple system call sequences to different threads, with each thread bound to a system call sequence, and to ensure that system call sequences with data correlation are allocated to different threads; The CPU core allocation module is used to bind the thread to different physical CPU cores and ensure that the thread has exclusive access to the physical CPU core through a priority mechanism. A high-precision timer module is used to set a unified trigger time. When the trigger time is reached, all threads are triggered simultaneously via a signal or callback function. The concurrent execution module is used to enable each thread to concurrently execute the allocated system call sequence on its own dedicated physical CPU core at the triggering time. The concurrent data conflict detection module is used to monitor the execution results and resource status of system calls, detect concurrency issues, and record error information.

2. A high-precision parallel system call detection method, employing the high-precision parallel system call detection architecture described in claim 1, characterized in that, Includes the following steps: Step S1: The system call generation module models the correlation of system calls and generates multiple system call sequences that are independent of each other. Step S2: The system call allocation module allocates the multiple system call sequences to different threads, with each thread bound to a system call sequence, and ensures that system calls with data correlation are allocated to different threads; Step S3: The CPU core allocation module binds the thread to different physical CPU cores and ensures that the thread has exclusive access to the physical CPU core through a priority mechanism. Step S4: The high-precision timer module sets a unified trigger time. When the trigger time is reached, all threads are triggered simultaneously through an adaptive waiting mechanism. Step S5: At the triggering time, the concurrent execution module enables each thread to concurrently execute the allocated system call sequence on its own dedicated physical CPU core; Step S6: The concurrent data conflict detection module monitors the execution results and resource status of system calls, detects concurrency issues, and records error information.

3. The high-precision parallel system call detection method according to claim 2, characterized in that, In step S1, the correlation modeling specifically includes: taking each system call captured during program execution as a node in a graph, and forming directed edges between nodes due to data dependencies or control dependencies; subsequently, processing the directed graph using a graph partitioning algorithm to extract multiple strongly connected components, and further obtaining mutually independent subgraphs through weakly connected component analysis, with each independent subgraph corresponding to an independent system call sequence.

4. The high-precision parallel system call detection method according to claim 2, characterized in that, In step S2, based on the result of subgraph partitioning of the directed graph in step S1, system calls are refined into independent subgraphs and converted into thread functions for concurrent execution; according to the size and scale of the independent subgraphs, each thread function corresponds to a subgraph, and each subgraph corresponds to a system call sequence.

5. The high-precision parallel system call detection method according to claim 2, characterized in that, In step S3, the exclusive use strategy of the CPU core includes: binding a specific thread to one or more specified logical CPU cores by setting the CPU affinity mask of the thread; at the same time, combining the isolcpus startup parameters provided by the Linux kernel, completely isolating the specified CPU core from the general process scheduler, so that the core can only allow the bound thread to run on it, thereby realizing the exclusive use of the CPU core.

6. The high-precision parallel system call detection method according to claim 2, characterized in that, In step S4, the adaptive waiting mechanism is as follows: all threads first synchronize to a common reference time point through cross-thread synchronization primitives; then, each thread enters a short-term precise busy-wait loop. In the final stage of the busy-wait, the thread actively yields the CPU and blocks on a high-precision timer; the high-precision timer sends a wake-up signal to all threads at a preset trigger time, thereby precisely waking up all threads so that they can start executing simultaneously from the beginning of their respective bound system call sequences.

7. The high-precision parallel system call detection method according to claim 2, characterized in that, In step S5, the high-precision timer generates a synchronization signal at a preset trigger time; after all threads receive the synchronization signal, they simultaneously start execution from the starting position of their respective bound independent system call sequences; each thread issues system calls in sequence according to the system call sequence corresponding to the subgraph, and coordinates between threads through synchronization primitives at the sequence synchronization point, thereby achieving high-precision concurrent execution of multiple threads.

8. The high-precision parallel system call detection method according to claim 2, characterized in that, In step S6, the concurrent data conflict detection module uses a vector clock or occurrence sequence relationship tracking algorithm to record the timing relationship between system calls in different threads, in order to accurately locate the point of occurrence of data competition.

9. An electronic device, characterized in that, It includes a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor, when executing the program, implements the method as described in any one of claims 2-8.

10. A computer-readable storage medium, characterized in that, It stores a computer program that, when executed by a processor, implements the method as described in any one of claims 2-8.

Images