Software Co-control Method and System for Multi-core SoC Verification Platform
By using a globally synchronized state table and unified service management to manage the processor core states in the multi-core SoC verification platform, the problems of scattered states and log synchronization in multi-core SoC verification are solved, improving the accuracy and reliability of verification and reducing complexity.
Patent Information
- Application Number
- CN202611329317.9
- Authority / Receiving Office
- CN · China
- Patent Type
- Applications(China)
- Current Assignee / Owner
- Filing Date
- 2026-08-30
- Publication Date
- 2026-11-17
AI Technical Summary
In existing multi-core SoC verification platforms, the operating states of multiple processor core software are scattered, lifecycle coordination is difficult, and log synchronization reliability is insufficient, resulting in high complexity, inconsistent results, and poor reliability in the verification process.
The Global Synchronization State Table (GST) and Global Synchronization Service (GST Service) are used to uniformly manage the software lifecycle state and log synchronization state of multiple processor cores. The raw data is monitored through shared memory, and a unified data structure is established for state acquisition and management to ensure the synchronization of lifecycle and log processing.
It enables unified management and lifecycle coordination of the software states of multiple processor cores during the multi-core SoC verification process, improving the accuracy, reliability and consistency of the verification process, and reducing the complexity and maintenance cost of the verification platform.
Smart Images

Figure CN123114877A_ABST
Abstract
Description
Technical Field
[0001] This invention relates to the field of integrated circuit verification technology, and more specifically, to a software collaborative control method and system for a multi-core SoC verification platform. Background Technology With the development of integrated circuit technology, the integration scale of System-on-Chip (SoC) is constantly expanding. A chip typically integrates multiple processor cores, memory modules, and various functional units. To ensure the functional correctness of complex SoC chips before tape-out, it is necessary to fully verify their hardware functions and software operation through a verification platform.
[0002] In SoC verification, software-driven verification is a commonly used method. This method involves running software test cases (C test cases) on the processor core, causing the processor to execute test tasks according to a preset process. The verification platform then analyzes the status information, test results, and output logs during the software execution to verify the functional correctness of the SoC design. With the development of multi-core processor architectures, multi-core SoC verification scenarios typically require multiple processor cores to execute corresponding software test cases, with the verification platform managing multiple software execution instances simultaneously.
[0003] Existing multi-core SoC verification platforms typically employ a software status management approach that manages each individual processor core separately. In this approach, each processor core runs its corresponding software test program, and the verification platform uses multiple independent monitoring modules to acquire the software running status, test results, and output logs of each core. Based on the information fed back from each monitoring module, the platform tracks and analyzes the software execution process.
[0004] In addition, existing multi-core SoC software verification solutions mainly include the following categories: First, the independent management of each processor core. The verification platform manages the software operation process of each processor core separately. There is a lack of a unified information exchange mechanism between the software instances of each processor core, and their lifecycle management is independent of each other, making it difficult to form the software operation status of the entire multi-core SoC.
[0005] Second, centralized software status monitoring methods. Some verification platforms can centrally collect software status information from multiple processor cores, but this is usually mainly used for status display, log statistics, or debugging assistance, and has not established a unified and collaborative control mechanism for the multi-core software operation process.
[0006] Third, lifecycle management based on software synchronization interfaces. Some solutions send start, end, and other status information to the verification platform through software synchronization interfaces to help the verification platform determine the software's running status. However, this method usually only achieves simple software status notifications and is difficult to meet the needs of lifecycle coordination, global status judgment, and exception handling in a multi-processor core parallel operation environment.
[0007] However, as the number of processor cores increases, the above technical solutions have gradually revealed the following shortcomings: On the one hand, for solutions that employ independent management of each processor core, the software running status of each processor core is typically maintained by different monitoring modules, lacking a unified management mechanism for the software status of multiple processor cores. This makes it difficult for the verification platform to form a view of the software running status of the entire multi-core SoC. As the number of processor cores increases, more software monitoring and management logic needs to be configured, leading to increased complexity and maintenance costs for the verification platform.
[0008] On the other hand, for solutions based on software synchronization interfaces or local state monitoring, the software execution paths, running speeds, and anomalies of different processor cores may differ during multi-core software testing, and the software completion times of each core are usually inconsistent. Existing verification platforms typically determine the completion status or local state of a single processor core, lacking a software lifecycle coordination mechanism for multiple processor cores. This can easily lead to problems such as the verification process ending prematurely before some processor cores have completed testing, or the verification process experiencing long waiting times due to anomalies in some processor cores.
[0009] Furthermore, multi-core SoC verification typically requires acquiring software logs generated by multiple processor cores simultaneously. Because the software execution of different processor cores is parallel, the log generation time and output speed of each core may differ. Existing log acquisition methods lack an effective synchronization management mechanism, easily leading to problems such as asynchronous log output, missing logs, out-of-order logs, or difficulty in verifying completeness, thus affecting the efficiency of subsequent debugging and analysis.
[0010] Therefore, in order to address the problems of dispersed operating states of multiple processor core software, difficulty in lifecycle coordination, and insufficient reliability of log synchronization during multi-core SoC verification, it is urgent to propose a software collaborative control method suitable for multi-core SoC verification scenarios to improve the accuracy and reliability of the verification process. Summary of the Invention
[0011] To address the problems of independent software operation states of multiple processor cores, lack of unified management mechanisms, difficulty in coordinating software lifecycles, and lack of synchronization guarantees in multi-core SoC verification processes, this invention provides a software collaborative control method and system for a multi-core SoC verification platform. By establishing a Global Synchronization State Table (GST) in the verification platform and utilizing a Global Synchronization Service (GST Service) to uniformly collect and maintain the state information generated by multiple processor cores during software testing, the software lifecycle state and log synchronization state of each processor core can be managed in a unified data structure. This avoids the problems of information dispersion and state inconsistency caused by multiple monitoring modules independently maintaining the state in existing technologies.
[0012] Furthermore, this invention uses a global synchronization state table to uniformly determine the software lifecycle status of multiple processor cores. Only after the software testing process of each processor core has been completed is the software log processing status of each processor core further determined to avoid incomplete verification results caused by some processor cores ending prematurely or log processing not being completed.
[0013] Furthermore, by synchronously managing the software log processing status of each processor core, this invention enables the verification platform to accurately determine the completion status of log processing, thus avoiding problems such as log omissions, asynchrony, or inability to confirm completeness during multi-core parallel operation.
[0014] Through the above methods, the present invention achieves unified management, lifecycle coordination and log synchronization control of the software states of multiple processor cores during the multi-core SoC verification process, thereby improving the reliability and consistency of the multi-core SoC software driver verification process.
[0015] In a first aspect, the present invention provides a software collaborative control method for a multi-core SoC verification platform, characterized in that it includes: A global synchronization status table is established in the verification platform. The global synchronization status table is used to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. The system collects raw data generated by each processor core during software testing through a global synchronization service, and updates the global synchronization status table based on the collected raw data. Based on the updated global synchronization status table, determine whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. After determining that the software lifecycle status of each processor core indicates that the corresponding software testing process has been completed, the global synchronization status table is used to determine whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
[0016] Secondly, the present invention also provides a software collaborative control system for a multi-core SoC verification platform, characterized in that it includes: A global synchronization status table is set in the verification platform to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. A global synchronization service is set up in the verification platform, and the global synchronization service includes a data acquisition layer, a state management layer, and a collaborative control layer. The data acquisition layer is used to collect the raw data generated by each processor core during software testing. The state management layer is used to update the global synchronization state table based on the collected raw data; The collaborative control layer also includes a lifecycle collaborative control unit and a synchronization determination unit; The lifecycle coordination control unit is used to determine, based on the updated global synchronization status table, whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. The synchronization determination unit determines, based on the global synchronization status table, whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed, after determining that the software lifecycle status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
[0017] The software collaborative control method and system for a multi-core SoC verification platform provided by this invention: First, by setting up a global synchronization status table, the software lifecycle status and log synchronization status of multiple processor cores are unified into a single data structure, providing the verification platform with a globally consistent view of the software's runtime status. Each verification component obtains its status information through the GST Service, eliminating the need to maintain its own status records. This avoids inconsistencies caused by separate management by multiple components and reduces the maintenance complexity of the verification platform.
[0018] Secondly, the software lifecycle status of each processor core is monitored uniformly through a global synchronization service. Each processor core reports its completion status by writing a lifecycle end flag. The GST Service only controls the verification platform to enter the completion preparation phase after detecting that all processor cores have completed their lifecycles. This avoids problems such as premature verification ending before some processor cores have finished or indefinite waiting due to some processor core malfunctions. Simultaneously, a timeout detection mechanism triggers exception handling if the conditions are not met within a preset time during the waiting process, further improving the robustness of the verification process.
[0019] Third, by setting up an independent log buffer queue for each processor core, and using dual recording of receive and commit counts, the platform ensures that all processor core log data has been fully collected and output before determining that log synchronization is complete. This mechanism effectively avoids problems such as asynchronous log output, missing logs, or out-of-order logs in multi-core concurrent scenarios, making the log information in the simulation results complete and reliable, and improving the efficiency of subsequent debugging and analysis.
[0020] Fourth, by allocating an independent shared memory address channel to each processor core, each processor core transmits raw data through its own corresponding channel, physically avoiding data conflicts and cross-interference during concurrent multi-core writes. The independent channels allocated to each processor core further include a log data channel, a log end marker channel, and a lifecycle end marker channel, achieving isolated transmission of different types of data and improving the reliability and identifiability of data transmission.
[0021] Fifth, by classifying and identifying the read and output log data, different processing strategies are executed based on the level identifiers (fatal level identifier, error level identifier, etc.) contained in the log data: For fatal errors, the verification process is immediately terminated to avoid unnecessary simulation consuming resources; for errors, the process is recorded and execution continues, preserving the complete error context for subsequent analysis; for normal information, it is output normally to ensure the readability of normal log information. This graded processing mechanism enables verification personnel to quickly locate the problem type and severity based on the log level, improving verification and debugging efficiency.
[0022] Sixth, this invention maintains consistency in software log output order, lifecycle synchronization process, and verification termination conditions through unified software state management and a deterministic log submission mechanism. This reduces randomness caused by differences in multi-core scheduling, log output timing variations, or different termination times of the verification platform, thereby improving the consistency and repeatability of verification results.
[0023] Seventh, the Global Synchronization Service (GST Service) can be implemented within the UVM verification platform as an independent verification component mounted on the UVM environment. When the number of processor cores changes, only the number of software state management objects in the global synchronization state table needs to be adjusted accordingly, without modifying the overall architecture of the verification platform, thus exhibiting good scalability and portability. Furthermore, the preset timeout time can be configured independently for each processor core, enabling the verification platform to adapt to real-world scenarios where different processor cores have varying operating speeds.
[0024] In summary, this invention effectively solves the technical problems of scattered operating states of multiple processor core software, difficulty in lifecycle coordination, and insufficient log synchronization reliability in the existing multi-core SoC verification process. It realizes unified aggregation of multi-core software operating states, collaborative control of lifecycle, and reliable log synchronization, thereby improving the accuracy, reliability, and automation level of multi-core SoC verification. Attached Figure Description
[0025] To more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of the present invention. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0026] Figure 1 This is a diagram of the overall architecture of the software collaborative control of the multi-core SoC verification platform provided in this embodiment of the invention; Figure 2 This is a schematic diagram of the overall architecture of the global synchronization service provided in an embodiment of the present invention; Figure 3 This is a flowchart of the shared memory raw data acquisition and global synchronization status table update provided in an embodiment of the present invention; Figure 4 This is a flowchart of log processing and global synchronization status table update provided in an embodiment of the present invention; Figure 5 This is a flowchart of the software lifecycle state determination provided in an embodiment of the present invention; Figure 6 This is a flowchart of the log synchronization status determination provided in an embodiment of the present invention. Detailed Implementation
[0027] The technical solution of the present invention will be further described in detail below with reference to the accompanying drawings and embodiments. Invention Overview As mentioned above, this invention provides a software collaborative control method and system for a multi-core SoC verification platform, which effectively realizes unified management of the core software status of multiple processors, lifecycle collaboration, and log synchronization determination during the multi-core SoC verification process, and solves the problems of scattered multi-core software status, difficulty in termination determination, and log synchronization in the prior art.
[0029] Exemplary methods The multi-core SoC verification platform software collaborative control method provided in this embodiment can be implemented based on the UVM verification platform. For example... Figure 1 As shown, in the method, the multi-core SoC is used as a design under test (DUT), which has a shared memory. The UVM verification platform monitors the bus write transactions of the shared memory and collects the raw data generated by each processor core during the software testing process to achieve software collaborative control of the multi-core SoC.
[0030] A multi-core SoC includes multiple processor cores: Core0, Core1, ..., CoreN. Each processor core runs its corresponding software test program (C Test Case), generating raw data such as log data, log end flag, and case end flag during the software testing process.
[0031] The internal shared memory of the DUT is divided into a log shared area and a status shared area. The log shared area stores log data and log end flags written by each processor core; the status shared area stores lifecycle end flags and exception / timeout flags written by each processor core. The capacity of the shared memory is typically 128KB to 256KB, with addresses statically allocated in 32-bit alignment. Each processor core is allocated an independent address space segment to ensure that data written by different processor cores does not overwrite each other. Shared memory has significant advantages over UART (Universal Asynchronous Receiver / Transmitter) printing: UART printing is extremely slow, limited by baud rate, and a single log entry may take hundreds of microseconds to complete, failing to meet the real-time requirements of high-speed simulation scenarios; while shared memory offers significant advantages such as high speed (nanosecond-level write response), large capacity (providing 128KB to 256KB of storage space), and convenient backend monitoring (bus signals are stable and measurable during the netlist stage), effectively meeting the high-throughput, low-latency status acquisition requirements of multi-core SoC verification scenarios. The UVM verification platform internally includes a Global Synchronization Service (GST Service), which is an independent verification component mounted within the UVM environment. This GST Service is defined and implemented as an independent class module, instantiated in the UVM environment layer, and has its own lifecycle (build_phase, run_phase, etc.). Verification test cases can directly access its provided interfaces through UVM's hierarchical path without needing to establish an additional independent communication channel. The GST Service monitors bus write transactions in the DUT's internal shared memory, collects raw data written by each processor core, and maintains the Global Synchronization Status Table (GST). The UVM Base Test (i.e., the test base class in the UVM verification platform, or specific test instances derived from this base class, used to define and execute specific verification test scenarios) calls the unified management interface provided by the GST Service to achieve software lifecycle coordination, log synchronization control, and software runtime status acquisition.
[0032] In this invention, each processor core executes a software test program (C TestCase) during the verification simulation. This program starts execution from the entry function and terminates when the exit function returns or the end function is called. A processor core runs only one software test process in a single verification simulation, and this process has a unique and complete lifecycle, including both running and completed states.
[0033] Each software test process generates multiple log outputs during its execution (e.g., debugging information, runtime status information, etc., output via printf or print statements). Log output and the software test process itself are two different levels of concepts: log output is an action within the software test process; the end of a log entry (i.e., the log end marker written by the software) only indicates that all characters of that log entry have been written to shared memory, not that the entire software test process has ended; the end of a software test process (i.e., the lifecycle end marker written by the processor core) indicates that the software test program on that core has completed execution and no new log output is generated. Therefore, this invention maintains the software lifecycle state and log synchronization state for each processor core, respectively. The former indicates whether the software test process for that core has ended, and the latter indicates whether all logs for that core have been completely output.
[0034] The two states are independent and determined sequentially: the lifecycle must end first, then log synchronization completion must be confirmed. Log data generation depends on the execution of the software test program. As long as the software test program is running, new log data may be generated at any time, making the total log volume uncertain. Only when the software test process is completely finished will log generation cease completely, and the total log volume become fixed. At this point, determining whether the logs have been completely output has a deterministic data basis. If attempts are made to determine log synchronization completion during the software test program's execution, new log data may be generated at any time, and the completed determination may be overwritten by new log writes, leading to unstable and meaningless results. Therefore, it is necessary to wait until the software test process for all processor cores is completed before confirming whether all logs for each core have been completely output, thus achieving reliable verification of completion.
[0035] The software collaborative control method for a multi-core SoC verification platform provided in this embodiment of the invention includes the following steps S101~S105 (not shown): S101: Establish a Global Synchronization State Table (GST) in the verification platform. The Global Synchronization State Table is used to maintain the software lifecycle state and log synchronization state corresponding to each of the multiple processor cores.
[0036] The global synchronization status table includes software status management objects corresponding to each processor core. Each software status management object is used to record the software lifecycle status and log synchronization status of the corresponding processor core.
[0037] Furthermore, during the global synchronization state table initialization phase, the software lifecycle state of inactive processor cores is marked as indicating that the corresponding software testing process has ended.
[0038] During the simulation initialization phase of the UVM verification platform (e.g., in the build phase or end-of-elaboration phase), the GST Service establishes and initializes the Global Synchronization State Table (GST). The GST is not a physical spreadsheet, but rather a structured collection of state records maintained by the GST Service within the verification platform. It centrally stores the software runtime state information of all processor cores participating in the verification. Logically, the GST is organized as a collection of multiple software state management objects, with each processor core corresponding to an independent software state management object. In one optional implementation, this software state management object is implemented through a struct or class instance, including fields such as processor core identifier (Core ID), software lifecycle state, log synchronization state, log buffer queue pointer, receive count, commit count, exception state, and timeout state. The software state management objects corresponding to multiple processor cores are further organized using arrays or associative arrays, with the processor core identifier as an index, to form a complete GST.
[0039] During initialization, the GST Service determines the number of processor cores enabled for the current verification and their corresponding core identifiers based on the verification test case configuration information. It creates a corresponding software state management object for each enabled core and initializes the values of each field—for example, initializing the software lifecycle state to "running" or "not started," initializing the receive and commit counts to 0, and initializing the log buffer queue to empty. For processor cores not participating in the current verification, their software lifecycle state is directly marked as "completed" (the corresponding binary flag is set to 1), and subsequent lifecycle determinations will no longer wait for these cores, thus avoiding unnecessary waiting.
[0040] The Global Synchronization State Table (GST) described in S101 is maintained uniformly by the state management layer in the GST Service. For example, as... Figure 2As shown, the state management layer is used to uniformly maintain the software running state of all processor cores. The maintained content includes fields such as Core ID, running state, Case End State, Log End State, Receive Count, Commit Count, exception state, timeout state, and Transaction ID (carrying a transaction identifier), providing a globally consistent state view to the upper layers. The state management layer organizes the software state management objects corresponding to each processor core using arrays or associative arrays, using the Core ID as an index to achieve fast querying and updating of the state of any core. In addition, the state management layer is also responsible for marking inactive processor cores during the GST initialization phase, directly marking the software lifecycle state of inactive processor cores as indicating that the corresponding software testing process has ended, so that they can be skipped in subsequent lifecycle determinations.
[0041] In this embodiment, the GST Service employs a layered architecture to implement the aforementioned functions. In one optional implementation, the various functional units of the GST Service (data acquisition layer, state management layer, coordination control layer, and interface service layer) can be implemented separately in multiple verification components, each independently developed and maintained, and finally coordinated through inter-component communication. However, as a preferred approach, this embodiment recommends encapsulating all functions within a single GST Service component for unified implementation, thereby reducing cross-component coupling and improving maintainability and reusability. The following sections, in conjunction with the method steps, explain the role of each layer of the GST Service in the corresponding steps.
[0042] The number of software state management objects in the GST described in this embodiment can be flexibly configured according to actual verification needs. When the number of processor cores changes, only the number of software state management objects and their corresponding core identifiers in the GST need to be adjusted, without modifying the overall architecture of the verification platform. Simultaneously, the number of shared memory address channels and the address allocation method can be expanded accordingly based on the number of cores.
[0043] S102: Collect raw data generated by each processor core during software testing through the global synchronization service, and update the global synchronization status table based on the collected raw data.
[0044] During the verification simulation phase, each processor core continuously generates various types of raw data while executing the software test program. This raw data includes, but is not limited to: log data written to shared memory by each processor core during software execution, log end flags indicating the completion of a complete log write, and case end flags indicating the completion of the core's test program execution. The log data is written byte-by-byte by the software; each byte written corresponds to one log character, and multiple log characters are concatenated in the order they were written to form complete log data. To achieve real-time acquisition and unified management of this raw data, this embodiment employs a shared memory-based communication mechanism. Each processor core writes the aforementioned raw data to a designated address area in the shared memory within the DUT according to a predetermined format, and the GST Service collects this data by monitoring bus write transactions in the shared memory. It should be noted that CPU data writing and GST Service monitoring and acquisition are two asynchronous processes: the CPU writes data according to its execution rhythm during software execution, while the GST Service continuously captures write events through bus monitoring. There is no need for synchronous waiting between the two, thus avoiding mutual blocking between software execution and platform monitoring.
[0045] The raw data carries a transaction ID, and the global synchronization service establishes an association between the raw data and the processor core based on the transaction ID. The transaction ID is used to identify the source and ownership of each piece of raw data in a multi-core concurrent write scenario. In one optional implementation, the transaction ID can be embedded in a specific field of the raw data, for example, reserving several bits in the header of the log data packet to carry the core identifier; in another optional implementation, implicit identification can also be achieved by using different shared memory address ranges for different cores, for example, Core0 is allocated the 0x40 address range and Core1 is allocated the 0x80 address range. The GST Service can directly determine which processor core the raw data belongs to based on the detected write transaction target address, without needing to carry an additional identifier field in the data content. Both of the above methods can achieve the transmission and identification of the transaction ID; the specific method used can be flexibly selected according to the implementation constraints of the actual verification platform.
[0046] The process of collecting raw data generated by each processor core during software testing through a global synchronization service specifically includes: The global synchronization service collects the raw data by monitoring bus write transactions in the shared memory.
[0047] Each processor core is allocated an independent shared memory address channel in the shared memory. The address space of each processor core is further divided into independent shared memory address channels based on function, including a log data channel, a log end flag channel, and a lifecycle end flag channel. These three types of channels are arranged consecutively in the address space and located using a base address plus an offset. For example, the base address of Core0's log data channel is 0x40, the Log End Flag channel is 0x44, and the Case End Flag channel is 0x48; Core1 is offset sequentially. Each channel occupies a 32-bit (4-byte) memory unit, and the address is 32-bit aligned. The above address allocation method is only an example. In actual applications, the base address and offset can be flexibly adjusted according to the total capacity of the shared memory and the number of channels required by each core, as long as the address segments of each core do not overlap. Each processor core writes the log data, log end flag, and lifecycle end flag generated during its software testing process into its corresponding address channel. By allocating an independent address segment to each processor core, each processor core uses non-overlapping address ranges when writing to the shared memory, physically avoiding data conflicts and cross-overwriting during concurrent multi-core writes. Each core can only access the address space within its own address range. Therefore, the raw data it writes will not be intertwined or confused with the raw data of other processor cores, ensuring the traceability and isolation security of the raw data in multi-core concurrent scenarios.
[0048] The data acquisition function involved in S102 is as follows: Figure 2 The data acquisition layer of the GST Service is shown. This layer monitors write transactions on the shared storage bus, identifies log / status area addresses, parses data types, content, and lengths, collects and stores write transactions in real time, identifies and parses software runtime events, and generates standardized event information for use by the status management layer and the coordination control layer.
[0049] GST Service monitors bus write transactions through the Bus Monitor component. The Bus Monitor continuously listens to the address signal, write enable signal, and write data signal on the shared memory bus. When a valid write transaction is detected, the Monitor captures the target address and write data value of the write transaction and transmits them to the shared memory acquisition unit of GST Service for further processing.
[0050] After receiving the write transaction information reported by the Monitor, the shared storage acquisition unit first determines which processor core the write transaction belongs to based on the core address range where the target address is located; then, based on the channel type to which the target address belongs (i.e., the log data channel, log end flag channel, or lifecycle end flag channel mentioned above), it determines the data type carried by the write transaction; finally, it encapsulates the written data value as the payload, along with the core identifier and data type, into a standardized software runtime event, and hands it over to the GST Service's state management layer for subsequent state update processing.
[0051] The step of updating the global synchronization status table based on the collected raw data includes: when a lifecycle end flag is detected in the raw data, updating the software lifecycle status of the corresponding processor core in the global synchronization status table to indicate that the corresponding software testing process has ended. This update action is performed by the GST Service's status management layer: after receiving the lifecycle end flag event reported by the shared storage acquisition unit, the status management layer locates the corresponding software status management object in GST based on the core identifier carried in the event, and updates the software lifecycle status field of that object from "running" to "completed". After this status update is completed, subsequent lifecycle determination steps can be based on the latest status in GST.
[0052] In actual operation of a multi-core SoC, the processor cores do not always start executing the software test program simultaneously. Due to differences in hardware design, after system reset, the arrival time of the reset signal, clock synchronization deviation, or inconsistent execution path length of their respective Boot ROM initialization code may cause differences in the timing of the entry into the user software test program. This startup time difference is a common phenomenon in multi-core SoC scenarios.
[0053] It should be noted that this invention does not impose any constraints or assumptions on the startup timing of each processor core. This method applies regardless of whether the cores start simultaneously, in stages, or enter the test program in any order. Specifically, the global synchronization service determines whether a core has completed testing by monitoring the lifecycle end flag independently written to the shared memory by each core, rather than relying on the startup order or startup time of the cores. Therefore, when a core starts executing the test program is jointly determined by the chip hardware reset logic and the software initialization process. This method does not impose constraints on the startup timing of each processor core, and is compatible with scenarios where cores do not start simultaneously. For cores not participating in the test, their status is directly marked as finished during the initialization phase, without waiting for them to start. For cores participating in the test, this method automatically begins status acquisition after their startup, without needing to know the startup time in advance, and only determines the end of the entire test process after all cores participating in the test have written the lifecycle end flag, thus being compatible with differences in the startup timing of any core and having broad applicability.
[0054] The step of updating the global synchronization status table based on the collected raw data includes: The log synchronization status of the corresponding processor core in the global synchronization status table is updated based on the received count and the submitted count.
[0055] The log synchronization status of the corresponding processor core in the global synchronization status table is updated according to the receive count and the commit count, including: for each processor core, when the receive count of the processor core is equal to the commit count and the log buffer queue is empty, the log synchronization status of the processor core is determined to indicate that the corresponding software log processing has been completed.
[0056] The receive count is used to record the amount of log data that the data acquisition layer has collected from the processor core, and the submit count is used to record the amount of log data that the collaborative control layer has output.
[0057] Only when both of these conditions are met can it be determined that the log synchronization status indication for the processor core has been completed.
[0058] like Figure 2 As shown, after receiving standardized event information reported by the data acquisition layer, the state management layer updates the global synchronization state table based on the collected raw data, specifically including: When the lifecycle end flag is detected, the software lifecycle status of the corresponding processor core in the global synchronization status table is updated to indicate that the corresponding software testing process has ended. When the receive count and commit count meet the consistency condition (i.e., they are equal and the log buffer queue is empty), the log synchronization status of the corresponding processor core in the global synchronization status table is updated to indicate that the corresponding software log processing has been completed.
[0059] Before updating the global synchronization status table based on the collected raw data, the following steps are included: The collected log data of the processor core is stored in the log buffer queue corresponding to the processor core, and the receive count is incremented each time it is stored. When the log end flag of the processor core is detected, the log data is read from the log buffer queue corresponding to the processor core and output. The commit count is incremented each time it is read, and the log end status of the processor core is initialized.
[0060] Specifically, log characters received by the log data channel are stored in the log buffer queue in a first-in, first-out manner, with the receive count incrementing synchronously. When the Log End Flag channel is written, all log characters are retrieved byte by byte from the log buffer queue of that processor core in enqueue order, concatenated into a complete log string, and then output via the UVM log output interface. During the output process, the commit count is incremented for each byte retrieved, initializing the log end state. After log processing is complete, the state management layer updates the log synchronization state of that core in GST based on the values of the receive and commit counts. This process ensures that the entire log data chain from collection to output is traceable and verifiable.
[0061] It is important to note that after each log output is completed, the log end state of the processor core must be cleared (i.e., initialized) to prepare for receiving the next log end flag. If this state is not cleared, the verification platform will not be able to effectively distinguish the current end flag from the previous residual state when the next log end flag arrives, which may lead to log output logic errors. Therefore, this state must be reset to its initial value after each log output is completed.
[0062] The step of reading and outputting log data from the log buffer queue corresponding to the processor core includes: All log data is read sequentially according to the order in which it is written to the log buffer queue. The log string is then reconstructed and output. Since log characters are written byte-by-byte to shared memory, the GST Service must retrieve and concatenate the data byte-by-byte from the log buffer queue in the order it was enqueued (i.e., the software writing order) to reconstruct the complete string output when the software calls a log output statement (e.g., the `print` function in C). Because there is a sequential relationship between the characters in the log string, disrupting this order during concatenation will distort the log content and affect the accuracy of subsequent debugging and analysis. Therefore, the log buffer queue adopts a first-in, first-out (FIFO) queue structure to ensure that log characters are retrieved sequentially according to the software writing order, thus completely reconstructing the original log content output by the software.
[0063] After reading and outputting log data from the log buffer queue corresponding to the processor core, the method further includes: classifying and identifying the read and output log data: when the log data contains a fatal level identifier, the verification platform terminates the verification; when the log data contains an error level identifier, the error is recorded and the verification continues; otherwise, the log data is output as ordinary information.
[0064] When a Fatal flag is detected in the log data, it indicates that an unrecoverable serious error has occurred during software operation. Such errors are typically caused by hardware design flaws or fatal software anomalies. Continuing the simulation is pointless, as it will not produce valid verification results and will continuously consume computational resources. Therefore, in this embodiment, upon detecting the Fatal flag, the verification platform terminates the verification process to avoid unnecessary simulation consuming resources. Simultaneously, the error context is preserved through the output log information for subsequent analysis and localization.
[0065] When an error level indicator is detected in the log data, it indicates that a functional abnormality or unexpected situation has occurred during software operation, but the error has not yet reached a severity level that would prevent the entire verification process from continuing. In this case, immediately terminating the simulation might prevent verification personnel from obtaining other potential error information from the same test case, increasing debugging attempts and analysis costs. Therefore, this embodiment records the error upon detection of the error indicator and continues the verification process, allowing the simulation to run continuously until the test is completed. This enables the collection of as much error information as possible within a single simulation, facilitating subsequent batch analysis.
[0066] The above log processing flow is as follows: Figure 2The log coordination control unit in the GST Service coordination control layer is executed as shown. The log coordination control unit is responsible for managing the read and write operations of the log buffer queues of each processor core and maintaining updates to the receive and commit counts. Specifically, log characters received by the log data channel are stored in the log buffer queue in a first-in, first-out manner, with the receive count incrementing synchronously. When the Log End Flag channel is written, the log coordination control unit retrieves all log characters byte by byte from the log buffer queue of that core in enqueue order, incrementing the commit count for each byte read, concatenating them into a complete log string, and then calling the UVM log output interface for output. After log processing is complete, the state management layer updates the log synchronization state of that core in GST based on the values of the receive and commit counts.
[0067] In addition, the log collaborative control unit is also responsible for classifying and identifying the log data after it has been read and output: when the log data contains a fatal level identifier, the verification platform terminates the verification; when the log data contains an error level identifier, the error is recorded and the verification continues; otherwise, the log data is output as ordinary information.
[0068] Figure 3 The process of acquiring raw data from shared memory and updating the global synchronization status table is demonstrated. For example... Figure 3 As shown, the GST Service continuously monitors write transactions on the shared storage bus (S301~S302). When it detects that a write transaction has accessed the log sharing area or the status sharing area (S303), it parses the written data and extracts the Core ID, data type, and payload (S304).
[0069] Process according to data type: If it is ordinary log data (log characters) (S305), GST Service writes the corresponding character data to the log buffer queue of the processor core (S306) and increments the Receive Count of the corresponding processor core (S307).
[0070] If it is the Log End Flag (S308), then the log commit process (S309) is triggered (the specific steps of the log commit process will be explained in detail below). Figure 4 (Detailed explanation follows); During the log submission process, the Commit Count (S310) of the corresponding processor core will be incremented.
[0071] If it is a Case End Flag (S311), then the Case End status of the corresponding processor core is updated, and GST Service updates the software lifecycle status of the processor core in the global synchronization status table to indicate that it has been completed (S312).
[0072] If it is an exception flag or a timeout flag (S313), then the exception / timeout status of the corresponding processor core is updated synchronously (S314).
[0073] After the above status update is completed, it is uniformly written into the Global Synchronization Status Table (GST) (S315) to realize centralized management of the running status of multiple processor core software.
[0074] Figure 4 This demonstrates the specific process by which the GST Service completes log processing and globally synchronized state table updates. For example... Figure 4 As shown, after the log submission process begins in S401, the GST Service reads log characters sequentially from the log buffer queue of the corresponding processor core according to the data writing order, increments the Commit Count of the corresponding processor core (S402), concatenates all log characters, and restores the complete software output string (S403). Then, it parses the log level (including INFO, WARNING, ERROR, and FATAL) and records the corresponding log's Transaction ID (S404). Based on the parsed log level, it calls the corresponding software log output interface (uvm_info / uvm_warning / uvm_error / uvm_fatal) to complete the log output (S405). After the log output is complete, it records that the log has been processed in the global synchronization status table (S406). At this point, the log submission process ends (S407). Through the above processing, a complete recovery and output of the software log is achieved in one operation, ensuring a one-to-one correspondence between the software log and the verification platform log.
[0075] S103: Based on the updated global synchronization status table, determine whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended.
[0076] After completing the shared memory data acquisition and GST status update, the software lifecycle status of each processor core is maintained in real time in the GST. In this step, the GST Service determines whether each processor core has completed its software testing process by reading the software lifecycle status field of each participating processor core recorded in the GST. Specifically, the GST Service triggers a lifecycle check at the synchronization wait point of the simulation verification process (e.g., after the main_phase phase) to query the Case End status of each processor core in the GST. If the software lifecycle status field of a processor core is marked as completed, it indicates that the processor core has written a case end flag to the shared memory, meaning that the software test program of the processor core has been executed. If the field is still running, it indicates that the processor core has not yet completed its software test program. The GST Service traverses all enabled processor cores and only determines that the lifecycle end condition is met when the software lifecycle status of all enabled processor cores indicates completion. If any enabled processor core has not yet completed, it is determined that the condition is not met, the GST Service enters a waiting state, and continuously checks the status changes in the GST periodically. The above determination process does not depend on the startup order or startup time of each processor core. No matter when each processor core enters the test program, as long as it eventually writes the life cycle end flag, it can be correctly identified and recorded, thus being compatible with scenarios where different processor cores in a multi-core SoC have different startup timings.
[0077] The lifecycle determination function involved in S103 is as follows: Figure 2 The GST Service's coordination control layer is shown. This layer includes a log coordination control unit, a lifecycle coordination control unit, and a synchronization determination unit. The lifecycle coordination control unit manages the Case End status of each processor core, performs lifecycle completion determination (checking whether the Case End status of all enabled processor cores has been set to completion), and triggers corresponding coordination logic when the status changes.
[0078] Figure 5 This demonstrates the software lifecycle status determination process for GST Service. For example... Figure 5As shown, GSTService queries the Case End status of each processor core in GST (S502) to determine whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended (S503). The Case End status refers to the software lifecycle status of each processor core. When the software test program of a processor core finishes execution, the core writes a lifecycle end flag (Case End Flag) to the shared memory. Upon detecting this flag, GSTService updates the Case End status of the corresponding core in GST to "completed".
[0079] If the Case End status of all processor cores is complete (S503 determines it is), then the lifecycle completion time is recorded (S506). The lifecycle end condition is met, the lifecycle is completed synchronously (S507), the process ends (S508), and the verification platform enters the verification end preparation stage.
[0080] If any processor core's Case End state is not yet complete (S503 indicates no), GSTService continues to wait (S504) and periodically rechecks the Case End state of each core in GST until all cores have completed or timed out. During the waiting process, if the waiting time exceeds the preset timeout (S505), exception handling is triggered and the verification ends to avoid the verification process from waiting indefinitely due to a single core being stuck.
[0081] S104: After determining that the software lifecycle status of each processor core indicates that the corresponding software testing process has been completed, determine whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed based on the global synchronization status table.
[0082] During the determination process, the GST Service checks each enabled core against the above conditions by querying the receive count, commit count, and log buffer queue status for each processor core in the GST. For any processor core, if the receive count is not equal to the commit count, it indicates that some log characters have been collected but not yet output; if the log buffer queue is not empty, it indicates that some log data is still waiting to be processed. Both of these situations indicate that the log data for that core has not been fully processed, and its log synchronization status should not be considered complete.
[0083] The GST Service continuously checks all enabled cores for the two conditions mentioned above at regular intervals. Only when the receive count of all enabled processor cores equals the corresponding commit count, and all log buffer queues are empty, does the GST Service determine that all software logs have been synchronized and notify the verification platform that the current verification process can be terminated. During the above determination process, if any core fails to meet the conditions for an extended period, an independent timeout detection mechanism will protect it (see the timeout detection section below for details).
[0084] The receive count records the amount of log data collected by the global synchronization service from the processor core, while the commit count records the amount of log data output by the global synchronization service. The receive count is in bytes; each time the software writes a byte of log data to the shared memory, the GST Service detects this, enqueues the byte, and increments the Receive Count. The commit count is also in bytes; each time the GST Service retrieves a byte of log data from the queue and prints it, the Commit Count is incremented.
[0085] It's important to note that the reason for introducing receive and commit counts, rather than relying solely on the log end flag, is that during the process of writing log data to shared memory, there is a timing difference between writing and output. The software may have already written all the characters of the last log entry to shared memory and added the corresponding log end flag, but at this point, the GST Service may not have yet read and output all the log characters from the log buffer queue. If only the log end flag is used as the criterion, it would incorrectly assume that the log synchronization is complete, when in fact some log characters are still stuck in the log buffer queue waiting to be output. The dual-counter mechanism, by comparing the receive count and the commit count, ensures that all collected log data has been completely output, fundamentally avoiding log omissions, duplications, or out-of-order issues caused by timing differences. Only when the receive count equals the commit count and the log buffer queue is empty is the log synchronization status of that processor core considered complete.
[0086] The log synchronization determination function involved in S104 is as follows: Figure 2 The GST Service coordination control layer shown is executed. The coordination control layer includes a log coordination control unit and a synchronization determination unit. The synchronization determination unit, upon receiving an update notification from the log coordination control unit, checks whether the receive count of each processor core equals the commit count and whether the log buffer queue is empty.
[0087] Figure 6 This demonstrates the log synchronization status determination process of the GST Service. For example... Figure 6As shown, the GST Service queries the Receive Count, Commit Count, and Log Buffer Queue Status of each processor core in the GST (S602). The Receive Count records the amount of log data the GST Service has collected from that processor core, and the Commit Count records the amount of log data the GST Service has read from the Log Buffer Queue and completed outputting. The Log Buffer Queue is used to temporarily store collected but not yet output log data.
[0088] For each processor core, the GST Service checks whether the Receive Count equals the Commit Count and the corresponding log buffer queue is empty (S603). If all processor cores meet the above conditions (S603 determines yes), then it is determined that all logs have been synchronously committed (S604), log synchronization is complete, the simulation can end (S605), and the process ends (S606).
[0089] If any processor core has not yet met the above conditions (S603 determines no), the GST Service continues to wait (S607) and periodically rechecks the receive count, commit count, and log buffer queue status of each core until all processor cores meet the conditions or a timeout occurs. It should be noted that... Figure 6 The "timed check" shown is merely an exemplary implementation of the present invention, and the present invention is not limited thereto. During the waiting process, if the waiting time exceeds the preset timeout, exception handling is triggered and the verification ends, avoiding infinite waiting of the verification process due to abnormal log output.
[0090] S105: Once it is determined that the log synchronization status of each processor core indicates that the corresponding software log processing has been completed, the verification platform ends the verification.
[0091] For example, such as Figure 2 As shown, the GST Service's interface service layer provides a unified control API to the verification platform for setting configurable parameters such as timeouts, allowing test programs to be flexibly adjusted according to actual verification needs. Simultaneously, the interface service layer also provides a status query API, allowing the verification platform to confirm the log synchronization status of each processor core before ending verification. Through the cooperation of these interfaces, the verification platform does not need to directly access GST's internal data structures; it can control and obtain software synchronization-related information solely through the interface service layer, thereby reducing the coupling between the verification platform's components and the GST Service.
[0092] After the S104 check passes, meaning all enabled processor cores meet the log synchronization completion conditions (receive count equals commit count and log buffer queue is empty), the GST Service confirms that all software logs have been completely output and there is no residual data. At this point, the software collaborative control process of the multi-core SoC verification platform is complete. This invention achieves fully automated collaborative control from the start of software execution to the reliable termination of the verification platform, without manual intervention, from the start of the software test program running on each processor core, to the unified determination of the lifecycle status, and then to the determination of log synchronization completion.
[0093] In addition, a timeout detection mechanism is included: a preset timeout period is set. If the software lifecycle status of each processor core does not indicate that the corresponding software testing process has ended within the timeout period, or the log synchronization status of each processor core does not indicate that the corresponding software log processing has been completed, then exception handling is triggered.
[0094] During the execution of software testing programs and log output, due to multi-core SoC hardware design anomalies, software program execution errors, or uncertainties in the simulation environment, situations may arise where software testing programs for some processor cores fail to complete for an extended period, or where some log data fails to be output completely for a prolonged time. To avoid indefinite waiting in the verification process due to single-core anomalies, this embodiment sets up a timeout detection mechanism in the GST Service, which runs in parallel with the judgment processes in S103 and S104. Specifically, the GST Service starts a timer when entering the lifecycle waiting phase and resets the timer to start counting again when entering the log synchronization waiting phase after the lifecycle judgment is passed. In any waiting phase, if the timeout duration exceeds the preset timeout period and the corresponding judgment condition is not met, a timeout exception is determined to have occurred, and the GST Service immediately triggers the exception handling process. The exception handling process includes: outputting an error log containing the timeout core identifier, timeout stage information, and timeout duration through the UVM verification platform's reporting mechanism; and calling the UVM simulation control interface to forcibly terminate the simulation process to avoid ineffective waiting and indefinite consumption of computing resources. Through the above timeout detection mechanism, even if some core components cannot complete the test or log output normally due to abnormal conditions, the verification platform can detect and terminate the verification process in a timely manner, thereby ensuring the reliability of the verification process.
[0095] The preset timeout period can be configured independently for each processor core. Since software test programs executed by different processor cores may have varying complexity and execution path lengths, the required runtime for each core may differ significantly. To accommodate this scenario, GST Service supports configuring timeout periods independently for each processor core. During GST initialization, a timeout threshold can be specified for each processor core through the configuration parameters of the verification test cases. For example, Core0, with its shorter expected runtime, can have a 1ms timeout, while Core1, with its longer execution path, can have a 5ms timeout. The timeouts for each core are independent and do not interfere with each other. A timeout for any core triggers the corresponding exception handling for that core, without affecting the timeout status of other cores.
[0096] Timeout detection covers two phases: the lifecycle waiting phase and the log synchronization waiting phase. The lifecycle waiting phase (S103) involves waiting for all enabled processor cores to write the case end flag. Timeout detection starts when the GST Service begins querying the case end status of each core. The log synchronization waiting phase (S104) involves waiting for the receive count of all enabled processor cores to equal the commit count and for the log buffer queue to be empty. Timeout detection is reset and restarted after the lifecycle determination passes and the GST Service begins checking the log synchronization status of each core. Both phases share a single timeout detection logic, but the timing start point and timeout threshold can be configured independently according to actual needs. If either phase fails to complete the timeout, the GST Service outputs an error log containing the timeout core identifier and timeout duration and forcibly terminates the simulation, avoiding the problem of the verification process waiting indefinitely due to a single core freezing.
[0097] It should be noted that the method of this invention is also applicable to single-core SoC verification scenarios. When there is only one processor core in the verification platform, GST only maintains the software state management object corresponding to that core. Lifecycle determination and log synchronization determination only need to be performed for that single core, and the rest of the working mechanism is exactly the same. Therefore, this invention does not impose a limitation on the number of processor cores and is compatible with both single-core and multi-core verification scenarios.
[0098] Exemplary System Accordingly, embodiments of the present invention also provide a software collaborative control system for a multi-core SoC verification platform, the system comprising: A global synchronization status table is set in the verification platform to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. The global synchronization service is configured within the verification platform, such as... Figure 2As shown, the global synchronization service includes a data acquisition layer, a state management layer, and a collaborative control layer; The data acquisition layer is used to collect the raw data generated by each processor core during software testing. The state management layer is used to update the global synchronization state table based on the collected raw data; The collaborative control layer also includes a lifecycle collaborative control unit and a synchronization determination unit; The lifecycle coordination control unit is used to determine, based on the updated global synchronization status table, whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. The synchronization determination unit determines, based on the global synchronization status table, whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed, after determining that the software lifecycle status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
[0099] The global synchronization status table includes software status management objects corresponding to each processor core. Each software status management object is used to record the software lifecycle status and log synchronization status of the corresponding processor core.
[0100] The data acquisition layer acquires the raw data by monitoring bus write transactions of the shared memory; The raw data includes log data written by each processor core to the shared memory, log end flags, and lifecycle end flags.
[0101] Each processor core is allocated an independent shared memory address channel in the shared memory. Each processor core writes the log data, log end flag, and lifecycle end flag generated during its software testing into its corresponding address channel.
[0102] Each processor core is allocated an independent shared memory address channel, which includes a log data channel, a log end flag channel, and a lifecycle end flag channel.
[0103] The state management layer is also used to: when a lifecycle end flag is detected in the original data, update the software lifecycle state of the corresponding processor core in the global synchronization state table to indicate that the corresponding software testing process has ended.
[0104] The log collaborative control unit is also used for: The collected log data of the processor core is stored in the log buffer queue corresponding to the processor core, and the receiving count is incremented each time it is stored. When the log end flag of the processor core is detected, log data is read from the log buffer queue corresponding to the processor core and output. The commit count is incremented for each read, and the log end status of the processor core is initialized. The state management layer is also used for: The log synchronization status of the corresponding processor core in the global synchronization status table is updated based on the received count and the submitted count.
[0105] The state management layer is also used for: For each processor core, when the receive count of that processor core equals the commit count and the log buffer queue is empty, the log synchronization status of that processor core is determined to indicate that the corresponding software log processing has been completed.
[0106] The state management layer is also used for: During the global synchronization state table initialization phase, the software lifecycle state of inactive processor cores is marked as indicating that the corresponding software testing process has ended.
[0107] The verification platform is the UVM verification platform, and the global synchronization service is an independent verification component mounted on the UVM environment.
[0108] The log collaborative control unit is also used for: Hierarchical identification of read and output log data: The verification platform terminates verification when the log data contains a fatality level identifier. When the log data contains an error level identifier, record the error and continue with the verification process; Otherwise, the log data will be output as ordinary information.
[0109] The log collaborative control unit is also used for: All log data is read sequentially according to the order in which it is written to the log buffer queue, and then the complete log string is reconstructed and output.
[0110] The lifecycle coordination control unit and the synchronization determination unit are also used for: A preset timeout period is set. If the software lifecycle status of each processor core does not uniformly indicate that the corresponding software testing process has ended, or the log synchronization status of each processor core does not uniformly indicate that the corresponding software log processing has been completed, then exception handling is triggered.
[0111] The preset timeout period can be configured independently for each processor core.
[0112] The raw data carries a transaction identifier, and the global synchronization service establishes an association between the raw data and the processor core based on the transaction identifier. It should be noted that although the operation of the software collaborative control method of the multi-core SoC verification platform of the present invention is described in a specific order in the accompanying drawings, this does not require or imply that these operations must be performed in that specific order, or that all the operations shown must be performed to achieve the desired result. Additionally or alternatively, certain steps may be omitted, multiple steps may be combined into one step, and / or one step may be broken down into multiple steps.
[0113] Furthermore, although several devices, units, or modules of the software collaborative control system for the multi-core SoC verification platform have been mentioned in the detailed description above, this division is merely exemplary and not mandatory. In fact, according to embodiments of the present invention, the features and functions of two or more modules described above can be embodied in one module. Conversely, the features and functions of one module described above can be further divided and embodied by multiple modules.
[0114] While the spirit and principles of the invention have been described with reference to several specific embodiments, it should be understood that the invention is not limited to the disclosed specific embodiments, and the division of aspects does not imply that features in these aspects cannot be combined for benefit; such division is merely for ease of description. The invention is intended to cover various modifications and equivalent arrangements included within the spirit and scope of the appended claims.
[0115] This invention provides: 1. A software collaborative control method for a multi-core SoC verification platform, characterized in that it includes: A global synchronization status table is established in the verification platform. The global synchronization status table is used to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. The system collects raw data generated by each processor core during software testing through a global synchronization service, and updates the global synchronization status table based on the collected raw data. Based on the updated global synchronization status table, determine whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. After determining that the software lifecycle status of each processor core indicates that the corresponding software testing process has been completed, the global synchronization status table is used to determine whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
[0116] 2. The method according to item 1, wherein the global synchronization state table includes software state management objects corresponding to each processor core, and each software state management object is used to record the software lifecycle state and log synchronization state of the corresponding processor core.
[0117] 3. The method according to item 1, characterized in that, the step of collecting the raw data generated by each processor core during software testing through a global synchronization service includes: The global synchronization service collects the raw data by monitoring bus write transactions in the shared memory; The raw data includes log data written by each processor core to the shared memory, log end flags, and lifecycle end flags.
[0118] 4. The method according to item 3, characterized in that, each processor core is allocated an independent shared memory address channel in the shared memory, and each processor core writes the log data, log end flag and lifecycle end flag generated during its software testing into its corresponding address channel.
[0119] 5. The method according to item 4, wherein the independent shared memory address channel allocated to each processor core includes a log data channel, a log end flag channel, and a lifecycle end flag channel.
[0120] 6. The method according to item 3, characterized in that updating the global synchronization state table based on the collected raw data includes: When the lifecycle end flag in the raw data is detected, the software lifecycle status of the corresponding processor core in the global synchronization status table is updated to indicate that the corresponding software testing process has ended.
[0121] 7. The method according to item 1, characterized in that, before updating the global synchronization state table based on the collected raw data, it includes: The collected log data of the processor core is stored in the log buffer queue corresponding to the processor core, and the receiving count is incremented each time it is stored. When the log end flag of the processor core is detected, log data is read from the log buffer queue corresponding to the processor core and output. The commit count is incremented for each read, and the log end status of the processor core is initialized. The step of updating the global synchronization status table based on the collected raw data includes: The log synchronization status of the corresponding processor core in the global synchronization status table is updated based on the received count and the submitted count.
[0122] 8. The method according to item 7, characterized in that updating the log synchronization status of the corresponding processor core in the global synchronization status table according to the receive count and the commit count includes: For each processor core, when the receive count of that processor core equals the commit count and the log buffer queue is empty, the log synchronization status of that processor core is determined to indicate that the corresponding software log processing has been completed.
[0123] 9. The method according to item 1, characterized in that it further comprises: During the global synchronization state table initialization phase, the software lifecycle state of inactive processor cores is marked as indicating that the corresponding software testing process has ended.
[0124] 10. The method according to item 1, wherein the verification platform is a UVM verification platform, and the global synchronization service is an independent verification component mounted on the UVM environment.
[0125] 11. The method according to item 8, characterized in that, after reading and outputting log data from the log buffer queue corresponding to the processor core, it further includes: Hierarchical identification of read and output log data: The verification platform terminates verification when the log data contains a fatality level identifier. When the log data contains an error level identifier, record the error and continue with the verification process; Otherwise, the log data will be output as ordinary information.
[0126] 12. The method according to item 8, characterized in that, the step of reading log data from the log buffer queue corresponding to the processor core and outputting it includes: All log data is read sequentially according to the order in which it is written to the log buffer queue, and then the complete log string is reconstructed and output.
[0127] 13. The method according to item 1, characterized in that it further comprises: A preset timeout period is set. If the software lifecycle status of each processor core does not uniformly indicate that the corresponding software testing process has ended, or the log synchronization status of each processor core does not uniformly indicate that the corresponding software log processing has been completed, then exception handling is triggered.
[0128] 14. The method according to item 13, wherein the preset timeout time supports independent configuration per processor core.
[0129] 15. The method according to any one of items 1 to 14, characterized in that the original data carries a transaction identifier, and the global synchronization service establishes an association between the original data and the processor core based on the transaction identifier.
[0130] 16. A software collaborative control system for a multi-core SoC verification platform, characterized in that it comprises: A global synchronization status table is set in the verification platform to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. A global synchronization service is set up in the verification platform, and the global synchronization service includes a data acquisition layer, a state management layer, and a collaborative control layer. The data acquisition layer is used to collect the raw data generated by each processor core during software testing. The state management layer is used to update the global synchronization state table based on the collected raw data; The collaborative control layer also includes a lifecycle collaborative control unit and a synchronization determination unit; The lifecycle coordination control unit is used to determine, based on the updated global synchronization status table, whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. The synchronization determination unit determines, based on the global synchronization status table, whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed, after determining that the software lifecycle status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
[0131] 17. The system according to item 16, wherein the global synchronization state table includes software state management objects corresponding to each processor core, and each software state management object is used to record the software lifecycle state and log synchronization state of the corresponding processor core.
[0132] 18. The system according to claim 16, wherein the data acquisition layer acquires the raw data by monitoring bus write transactions of the shared memory; The raw data includes log data written by each processor core to the shared memory, log end flags, and lifecycle end flags.
[0133] 19. The system according to claim 18, characterized in that each processor core is allocated an independent shared memory address channel in the shared memory, and each processor core writes the log data, log end flag and lifecycle end flag generated during its software testing into its corresponding address channel.
[0134] 20. The system according to claim 19, wherein the independent shared memory address channels allocated to each processor core respectively include a log data channel, a log end flag channel, and a lifecycle end flag channel.
[0135] 21. The system according to claim 18, wherein the state management layer is further configured to: when a lifecycle end flag is detected in the original data, update the software lifecycle state of the corresponding processor core in the global synchronization state table to indicate that the corresponding software testing process has ended.
[0136] 22. The system according to claim 16, characterized in that the log collaborative control unit is further configured to: The collected log data of the processor core is stored in the log buffer queue corresponding to the processor core, and the receiving count is incremented each time it is stored. When the log end flag of the processor core is detected, log data is read from the log buffer queue corresponding to the processor core and output. The commit count is incremented for each read, and the log end status of the processor core is initialized. The state management layer is also used for: The log synchronization status of the corresponding processor core in the global synchronization status table is updated based on the received count and the submitted count.
[0137] 23. The system according to claim 22, wherein the state management layer is further configured to: For each processor core, when the receive count of that processor core equals the commit count and the log buffer queue is empty, the log synchronization status of that processor core is determined to indicate that the corresponding software log processing has been completed.
[0138] 24. The system according to claim 16, characterized in that the state management layer is further configured to: During the global synchronization state table initialization phase, the software lifecycle state of inactive processor cores is marked as indicating that the corresponding software testing process has ended.
[0139] 25. The system according to item 16, wherein the verification platform is a UVM verification platform, and the global synchronization service is an independent verification component mounted on the UVM environment.
[0140] 26. The system according to claim 23, wherein the log collaboration control unit is further configured to: Hierarchical identification of read and output log data: The verification platform terminates verification when the log data contains a fatality level identifier. When the log data contains an error level identifier, record the error and continue with the verification process; Otherwise, the log data will be output as ordinary information.
[0141] 27. The system according to claim 23, wherein the log collaboration control unit is further configured to: All log data is read sequentially according to the order in which it is written to the log buffer queue, and then the complete log string is reconstructed and output.
[0142] 28. The system according to claim 16, characterized in that the lifecycle coordination control unit and the synchronization determination unit are further configured to: A preset timeout period is set. If the software lifecycle status of each processor core does not uniformly indicate that the corresponding software testing process has ended, or the log synchronization status of each processor core does not uniformly indicate that the corresponding software log processing has been completed, then exception handling is triggered.
[0143] 29. The system according to claim 28, wherein the preset timeout time supports independent configuration per processor core.
[0144] 30. The system according to any one of items 16 to 29, characterized in that the original data carries a transaction identifier, and the global synchronization service establishes an association between the original data and the processor core based on the transaction identifier.
Claims
1. A method for software co-control of a multi-core SoC verification platform, characterized in that, include: A global synchronization status table is established in the verification platform. The global synchronization status table is used to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. The system collects raw data generated by each processor core during software testing through a global synchronization service, and updates the global synchronization status table based on the collected raw data. Based on the updated global synchronization status table, determine whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. After determining that the software lifecycle status of each processor core indicates that the corresponding software testing process has been completed, the global synchronization status table is used to determine whether the log synchronization status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
2. The method of claim 1, wherein, The global synchronization status table includes software status management objects corresponding to each processor core. Each software status management object is used to record the software lifecycle status and log synchronization status of the corresponding processor core.
3. The method of claim 1, wherein, The process of collecting raw data generated by each processor core during software testing through a global synchronization service includes: The global synchronization service collects the raw data by monitoring bus write transactions in the shared memory; The raw data includes log data written by each processor core to the shared memory, log end flags, and lifecycle end flags.
4. The method of claim 3, wherein, Each processor core is allocated an independent shared memory address channel in the shared memory. Each processor core writes the log data, log end flag, and lifecycle end flag generated during its software testing into its corresponding address channel.
5. The method according to claim 4, characterized in that, Each processor core is allocated an independent shared memory address channel, which includes a log data channel, a log end flag channel, and a lifecycle end flag channel.
6. The method according to claim 3, characterized in that, The step of updating the global synchronization status table based on the collected raw data includes: When the lifecycle end flag in the raw data is detected, the software lifecycle status of the corresponding processor core in the global synchronization status table is updated to indicate that the corresponding software testing process has ended.
7. The method according to claim 1, characterized in that, Before updating the global synchronization status table based on the collected raw data, the following steps are included: The collected log data of the processor core is stored in the log buffer queue corresponding to the processor core, and the receiving count is incremented each time it is stored. When the log end flag of the processor core is detected, log data is read from the log buffer queue corresponding to the processor core and output. The commit count is incremented for each read, and the log end status of the processor core is initialized. The step of updating the global synchronization status table based on the collected raw data includes: The log synchronization status of the corresponding processor core in the global synchronization status table is updated based on the received count and the submitted count.
8. The method according to claim 7, characterized in that, Update the log synchronization status of the corresponding processor core in the global synchronization status table according to the received count and the committed count, including: For each processor core, when the receive count of that processor core equals the commit count and the log buffer queue is empty, the log synchronization status of that processor core is determined to indicate that the corresponding software log processing has been completed.
9. The method according to claim 1, characterized in that, Also includes: During the global synchronization state table initialization phase, the software lifecycle state of inactive processor cores is marked as indicating that the corresponding software testing process has ended.
10. A software collaborative control system for a multi-core SoC verification platform, characterized in that, include: A global synchronization status table is set in the verification platform to maintain the software lifecycle status and log synchronization status of each of the multiple processor cores. A global synchronization service is set up in the verification platform, and the global synchronization service includes a data acquisition layer, a state management layer, and a collaborative control layer. The data acquisition layer is used to collect the raw data generated by each processor core during software testing. The state management layer is used to update the global synchronization state table based on the collected raw data; The collaborative control layer also includes a lifecycle collaborative control unit and a synchronization determination unit; The lifecycle coordination control unit is used to determine, based on the updated global synchronization status table, whether the software lifecycle status of each processor core indicates that the corresponding software testing process has ended. The synchronization determination unit determines whether the log synchronization status of each processor core indicates that the corresponding software testing process has been completed based on the global synchronization status table after determining that the software lifecycle status of each processor core indicates that the corresponding software log processing has been completed. Once the verification platform confirms that the log synchronization status of each processor core indicates that the corresponding software log processing is complete, the verification process ends.
