CPU performance test method in Conda environment and application

Abstract

The invention relates to a CPU performance test method in a Conda environment and application, belongs to the field of computer performance evaluation and optimization, and realizes comprehensive evaluation of CPU performance by combining LAMMPS and LLCBench tools. According to the method, a test platform is quickly built through a Conda environment, and the computing performance and the parallel processing capacity of a CPU can be evaluated by using LAMMPS; the bandwidth and delay characteristics of caches (L1, L2 and L3) at all levels of the CPU can be tested through LLCBinch. By combining the two tools, the method realizes the comprehensive test of the computing performance and the cache performance of the CPU, has the advantages of high efficiency, repeatability and wide application range, and provides scientific support for hardware performance evaluation and optimization.

Description

TECHNICAL FIELD

[0001] The application relates to a CPU performance test method, device, equipment and medium in a Conda environment, and belongs to the field of computer performance evaluation and optimization. BACKGROUND

[0002] With the continuous improvement of computer hardware performance, especially the widespread application of multi-core CPUs and large cache architectures, how to comprehensively and accurately evaluate the computing performance, cache performance and parallel processing capability of CPUs has become a research hotspot. In practical applications, different CPU architectures and designs have a significant impact on the execution efficiency of application programs, so benchmark testing for specific tasks is of great significance.

[0003] In the field of performance testing, LAMMPS (Large-scale Atomic / Molecular Massively Parallel Simulator) is a tool widely used in molecular dynamics simulation, which has high configurability and parallelism, and can effectively utilize multi-core and multi-thread architectures, thus becoming one of the important tools for evaluating CPU computing and parallel performance. In addition, LLCBench (Low-Level Cache Benchmark) is a tool that focuses on testing CPU cache performance, which can accurately evaluate the bandwidth and delay characteristics of CPU caches (L1, L2, L3) at all levels, and is an important means of analyzing system bottlenecks.

[0004] In order to improve the flexibility and accuracy of performance testing, Conda environment as a package management and environment isolation tool can quickly build a test environment and install related tool packages. By using Conda environment, the problem of version conflict of different dependent packages can be avoided, and consistent environment support for benchmark testing on different hardware platforms can be provided. Therefore, integrating LAMMPS and LLCBench into the Conda environment and developing a general benchmark test method for CPUs can more efficiently evaluate hardware performance.

[0005] In addition, in the software testing industry, the deployment of the test environment includes steps such as software automated testing tools and environment deployment, and when personnel deploy automated testing tools and environments on different operating systems, different adaptation and compatibility problems may occur, making it inconvenient to deploy the test environment on different operating systems. SUMMARY

[0006] Therefore, in view of the deficiencies of the prior art, the present application provides a CPU benchmarking method based on Conda environment, which comprehensively evaluates the performance of CPU by combining LAMMPS and LLCBench tools. This method quickly builds a test platform through Conda environment, solves the problems of dependency conflicts and complex environment configuration, and can be applied to various hardware architectures and operating systems.

[0007] By using LAMMPS, the computing performance and parallel processing capability of CPU can be evaluated; by using LLCBench, the bandwidth and delay characteristics of CPU caches (L1, L2, L3) can be tested. By combining these two tools, this method realizes comprehensive testing of the computing performance and cache performance of CPU, has the advantages of high efficiency, repeatability and wide application range, and provides scientific support for hardware performance evaluation and optimization.

[0008] Term explanation Python refers to a high-level programming language, which has the characteristics of simple syntax, high readability and supports multiple programming paradigms (such as object-oriented, functional programming). It has rich scientific computing and data analysis libraries such as NumPy, SciPy and Pandas, and is widely used in performance testing, data processing and algorithm implementation. The cross-platform feature of Python also makes it widely used in multi-core CPU performance analysis and experimental automation.

[0009] Perf refers to the performance analysis tool of Linux system, which is used to monitor the running state of CPU and operating system. It can capture hardware events (such as instruction count, L3 cache hit / miss) and software events (such as context switch, thread scheduling), helping to analyze the performance bottleneck of the program. Perf is suitable for fine analysis of multi-core processors, NUMA architecture or thread migration behavior.

[0010] The technical solutions of the present application are as follows: A CPU performance testing method under Conda environment, comprising the following steps: (1) Environment construction A unified test platform is built using Conda environment, and the required dependent tools and libraries are installed adaptively, including LAMMPS, LLCBench, Python and perf. The use of Conda environment avoids the differences between operating systems and dependency conflicts, ensuring the rapid deployment and consistency of the test environment.

[0011] For different hardware platforms (such as x86, ARM or domestic CPU architecture), the Conda environment is optimized to adapt to the corresponding tool chain of the architecture.

[0012] (2) Integration and testing of tools (2-1) LAMMPS benchmarking: The test parameter script for performance testing is specified, perf is used, and the computing performance of the CPU, including floating point operation capability, memory access efficiency, and multi-core parallel processing capability, is tested by executing the standard benchmarking script of LAMMPS; In addition, the performance of the CPU under different task sizes and thread numbers is tested using multi-threading and MPI mode; and performance result data is collected by the Jenkins tool; Preferably, before the LAMMPS tool executes the LAMMPS test script, it further includes: The execution path of the LAMMPS test script, the test particles, the load mode, and the test task are specified; An execution project is created in the LAMMPS tool; The LAMMPS tool sets up coroutines based on the event-driven architecture according to the number of concurrent particles and the test duration; The coroutines are called through an event loop to perform performance testing; The LAMMPS tool runs the LAMMPS program by executing the LAMMPS test script according to the execution path, test particle scene, load mode, test task, and performance indicators in the execution project.

[0013] Further, the LAMMPS tool performs performance testing according to the test parameters, and further includes: The execution of performance testing is monitored and controlled through the TOP interface.

[0014] Further, after the performance result data is collected by the Jenkins tool, it further includes: The LAMMPS tool generates a performance test report according to the performance result data, wherein the performance result data includes CPI, IPC, cache rate, and running time, and the performance test report includes performance indicators and error reports.

[0015] (2-2) LLCBench benchmarking: The test parameter script for cache performance testing is specified, the LLCBench tool is used, and the bandwidth and delay characteristics of the cache (L1, L2, L3) of the test CPU are evaluated by executing the standard CacheBench test module, the influence of the cache architecture on the overall system performance is comprehensively analyzed, including the access throughput, access response time, and data prefetching and reuse efficiency of the cache; In addition, the CPU is tested under different data scales and concurrency levels using different vector lengths, access granularities, and thread numbers, and cache test result data is collected by the LLCBench tool. Preferably, the LLCBench tool further includes the following before executing the CacheBench test script: specifying an execution path, a test granularity, an access mode, and a test task of the LLCBench test module; creating an execution project in the LLCBench tool; the LLCBench tool sets a test flow based on a cache model driven architecture according to a vector length, a cache level, and a thread number; the test flow is called through an internal loop mechanism to perform cache performance testing; the LLCBench tool executes the LLCBench core module by executing the CacheBench test program according to an execution path, an access vector, a cache level, an access mode, and a performance indicator in the execution project.

[0016] Further, the LLCBench tool performs cache performance testing according to test parameters, and further includes the following: the execution of the cache test is monitored and controlled through the TOP interface; supporting collection of read-write bandwidth (Cache Bandwidth) and access delay (Cache Latency) indicators of each level of cache.

[0017] Further, after collecting cache test result data by the LLCBench tool, the following is further included: the LLCBench tool generates a cache performance test report according to performance result data, wherein the performance result data includes delay statistics of different cache levels, read-write bandwidth values, and analysis of the impact of access granularity on performance; the performance test report includes cache indicator curves, hotspot level identification results, and error detection reports.

[0018] (3) Data analysis and result verification To comprehensively evaluate the processor performance, the data output by LAMMPS and LLCBench is integrated to build a multi-dimensional index system including CPI (average clock cycle per instruction), IPC (instructions per cycle), L3 cache hit rate in Perf, cache bandwidth, and running time. CPI reflects the average delay of instruction execution, and the lower the value, the higher the pipeline efficiency. IPC measures the instruction parallel processing capability, and the higher the value, the stronger the processor execution efficiency. Cache hit rate represents the data access success rate, and the higher the value, the better the data locality and the lower the main memory dependence. Cache bandwidth reflects the data throughput capacity per unit time, and the larger the value, the stronger the processor's support capacity for large-scale data load. Running time is a direct performance indicator perceived by users, and the shorter the time, the higher the overall execution efficiency. In general, low CPI, high IPC, high cache hit rate, large bandwidth, and short running time are important manifestations of excellent processor performance, which can reflect the comprehensive processing capability of the processor in compute-intensive and memory-intensive scenarios.

[0019] The accuracy and consistency of the data are verified, and the normalized data comparison and manual inspection of extreme values are performed through repeated experiments to ensure the reliability of the test results. Through the above steps, the performance test of the CPU can be completed, and the CPU architecture (brand website or lstopo tool query) is analyzed to find the CPU performance bottleneck.

[0020] (4) Extensibility of the method Based on this framework, other benchmarking tools such as stress and PyBench can be integrated through Conda environment or direct command line to cover more performance dimensions. In addition, the Conda environment supports the running of automated scripts, which can be used for batch testing or continuous performance monitoring scenarios.

[0021] A computer-readable storage medium having a program stored thereon, the program being executed by a processor to implement the steps of the CPU performance testing method in the Conda environment as described above.

[0022] An electronic device comprising a memory, a processor, and a program stored on the memory and executable on the processor, wherein the processor executes the program to implement the steps of the CPU performance testing method in the Conda environment as described above.

[0023] The technical solution integrates the Conda environment and high-performance testing tools, simplifies the process of CPU performance evaluation, ensures the reliability and scientificity of the test results, and provides flexible expansion capabilities suitable for hardware performance evaluation, system optimization, and academic research scenarios.

[0024] The application provides a CPU benchmark test method integrating LAMMPS and LLCBench in a Conda environment. Although LAMMPS or LLCBench may be used for performance testing alone, or Conda is mentioned as an environment management tool, there is a lack of effective combination of the three to form an innovative solution for comprehensive performance evaluation of CPU and cache. The application integrates the two functionally complementary tools LAMMPS and LLCBench into the unified, stable and highly reproducible environment provided by Conda, solving the complex dependency management and environment configuration problems in traditional performance testing, and enabling more comprehensive and in-depth systematic evaluation of the computing efficiency, parallel scalability and memory access performance of CPU, thereby providing more insightful CPU performance evaluation reports.

[0025] The application has the following beneficial effects: The application has the following beneficial effects: 1. The Conda environment is used to quickly build a test environment, without the need for manual dependency conflict resolution, significantly reducing test preparation time and improving test efficiency, while adapting to multiple hardware platforms and operating systems.

[0026] 2. The combination of LAMMPS and LLCBench tools enables comprehensive evaluation of CPU performance from multiple dimensions such as computing performance (floating point operation capability, parallel processing capability, etc.) and cache performance (bandwidth and delay of L1 / L2 / L3 cache), providing more accurate performance data.

[0027] 3. The portability of the Conda environment ensures consistency and repeatability of the benchmark test process in different systems and environments, facilitating fair comparison of hardware performance and verification of scientific research results.

[0028] 4. The application supports performance testing of multi-core CPUs and different architectures, and is suitable for multiple fields such as scientific research, engineering, hardware development and optimization, especially in high-performance computing and hardware selection scenarios.

[0029] 5. The test framework is based on Conda and open source tools, which can easily integrate other benchmark test tools or performance analysis methods, facilitating further expansion of the test range and optimization of the test process. BRIEF DESCRIPTION OF DRAWINGS

[0030] Figure 1 Flow chart for CPU performance test in Conda environment; Figure 2 LAMMPS performance test flowchart; Figure 3 LLCBench performance test flowchart. DETAILED DESCRIPTION

[0031] The application will be further described below by way of examples and with reference to the accompanying drawings, but is not limited thereto.

[0032] Example 1

[0033] A CPU performance testing method under a Conda environment includes the following steps: (1) Environment construction and tool configuration 1-1. Conda environment configuration Create a separate Conda environment to manage dependent packages, libraries and tools, and ensure that the test environment does not interfere with other system applications; you can use conda list --explicit or manually create an environment.yml file to lock all packages and their versions in the environment, as follows is an example of environment.yml: name: demo channels: - conda-forge - defaults dependencies: - python=3.9 - numpy=1.21.0 - scipy=1.7.1 - LAMMPS - llcBench The environment can be configured to adapt to the tool chain of the hardware architecture (such as x86, ARM or domestic CPU) and operating system, ensuring consistency across different platforms.

[0034] 1-2. Dependency management method Use the Conda environment to build a unified test platform, and adaptively install the required dependent tools and libraries, including LAMMPS, LLCBench, Python, and perf; introduce dependency checking and version control algorithms within the Conda environment to ensure that the versions of the test tools and libraries are compatible with the target hardware platform. After all dependent packages are installed, check whether each tool can be normally started and is complete in function.

[0035] (2) Integration and testing of tools (2-1) Perform LAMMPS benchmark algorithm testing Creating a test file for LAMMPS particles typically requires writing an input script that includes a description of the particle system, initialization parameters, interaction models, and simulation time steps. The LAMMPS particle test file is created as follows.

[0036] 1. Creation of particle systems First, you need to define the particle type, position, and interactions. Here are some key steps and settings: 1.1 Selecting a Unit System LAMMPS supports multiple unit systems (such as metal, real, si, etc.). The metal unit system is usually chosen because it has wider applicability.

[0037] 1.2 Defining Atomic Style LAMMPS supports different atomic styles, such as atomic, charge, and atomic, and the specific choice depends on the requirements of the simulation system.

[0038] 1.3 Define the simulation region Use the `region` command to define a simulated region.

[0039] Define a cubic region for creating particles: region box block 0 10 0 10 0 10 create_box 1 box This will create a region in the space x=0 to x=10, y=0 to y=10, z=0 to z=10, and create a box containing 1 type of atom for that region.

[0040] 1.4 Creating Particles Particles are generated using the `create_atoms` command. This generates atoms within an FCC lattice within a cubic region. lattice FCC 4.0 create_atoms 1 box Here, fcc indicates the use of a face-centered cubic lattice structure, and 4.0 represents the lattice constant.

[0041] 1.5 Setting Particle Type and Attributes Set particle attributes such as type and mass. Set particle mass: mass 1 58.69 This sets the mass of type 1 particles in atomic mass units.

[0042] 2. Setting up the interaction model LAMMPS provides a variety of different interaction models that determine how particles interact with each other.

[0043] 2.1 Lennard-Jones potential The Lennard-Jones potential is used to describe the interaction between two particles to model gas and liquid systems.

[0044] Setting up the inter-particle interaction: pair_style lj / cut 2.5 pair_coeff 1 1 1.0 1.0 2.5 Here we set up the LJ potential between type 1 particles with epsilon = 1.0, sigma = 1.0, and a cutoff distance of 2.5.

[0045] 2.2 Embedded Atom Model (EAM) For metallic systems, the EAM potential model can be used: pair_style eam pair_coeff * * Al99.eam.alloy Al Al99.eam.alloy is an EAM potential file included with LAMMPS that describes the interaction between aluminum atoms.

[0046] 2.3 Inter-particle forces To add a binding force between molecules or particles, use the bond_style and angle_style commands.

[0047] 3. Setting up the simulation 3.1 Setting the time step Use the timestep command to set the time step for the simulation. Set the time step to 0.005 ps: timestep 0.005 3.2 Equilibration and production run It is often necessary to run the simulation for a certain amount of time to ensure that the particle system reaches thermal equilibrium. Use the run command to set the run time: thermo 100 run 10000 Here we run the simulation for 10000 steps, outputting thermodynamic information every 100 steps.

[0048] 4. Output of information 4.1 Output of particle data LAMMPS supports multiple data output formats for recording particle positions, velocities, etc. Information output is generally done through dump: dump 1 all atom 100 dump.LAMMPStrj Here, we set to output particle information every 100 steps.

[0049] 4.2 Output of thermodynamic data Thermo_style can be used to output temperature, pressure, energy, and other thermodynamic quantities.

[0050] thermo_style custom step temp pe ke etotal press 5. perf monitoring perf can monitor various kernel events to help record the interaction between the kernel and hardware. These events include CPU instruction execution and cache performance. At the kernel level, perf can collect performance data by tracking specific hardware events or software events.

[0051] 5.1 Sampling perf records specific hardware events (such as CPU cycles, cache hits) through periodic sampling and outputs them. These sampling data can help you evaluate the efficiency of program running and find possible bottlenecks.

[0052] 5.2 Design of perf monitoring for LAMMPS When performing LAMMPS performance analysis, use perf to monitor and analyze CPU performance, cache performance, and memory access, etc. The following is the design of perf monitoring for LAMMPS: 5.2.1 Determination of monitoring events First, find the supported kernel events of the CPU through perf list, and monitor the supported kernel events through perf.

[0053] Here, the CPU performance-related CPI and cache miss rate are monitored, so there are the following event monitoring: perf record -e cycles,instructions Here, perf is used to record CPU cycles and instruction counts to obtain CPI data for LAMMPS.

[0054] CPI is calculated by the following formula: CPI = Total Instructions / Total CPU Cycles perf record -e cache-references,cache-misses By monitoring cache hits and misses, you can help find performance bottlenecks in your code.

[0055] 5.2.2 Tracing LAMMPS with perf To start performance monitoring of LAMMPS, use the following command: Monitor the LAMMPS process: If LAMMPS is running during the test, and the process ID is pid, you can start perf with the following command: perf record -p <pid>-e cycles,instructions,cache-references,cache-misses -a Here, the -p option specifies the ID of the LAMMPS process, -e is used to specify the monitored events, and -a indicates full-system monitoring.

[0056] In addition, you can also directly execute LAMMPS and combine the perf command with it: perf record -e cycles,instructions,cache-references,cache-misses. / lmp<input_script> In this way, perf will monitor the performance of LAMMPS during its execution.

[0057] 5.2.3 Analysis of Results After the LAMMPS run is completed, the performance data recorded by perf can be viewed through perf report to generate a detailed performance report.

[0058] (2-2) LLCBench Cache Performance Evaluation Method 1. Cache Bandwidth Evaluation Bandwidth Calculation: Based on the test principle of LLCBench tool, record the calculation of cache bandwidth. First, by executing large-scale data access tasks (such as memory loading, storage, etc.), measure the bandwidth performance of different cache levels (L1, L2, L3).

[0059] 2. Cache Delay Analysis Delay Measurement Model: Through data blocks of different sizes (such as 16KB, 64KB, 1MB, etc.), record the cache delay measurement. Through different access modes (such as sequential access, random access), analyze the cache delay in depth, and further evaluate the impact of cache architecture on performance. CPU computing speed increases with the size of the data block, which proves that the performance of the CPU is better.

[0060] (3) Data Analysis and Result Processing 1. Performance Data Extraction and Cleaning Algorithm For data cleaning of LAMMPS and LLCBench output, first, data preprocessing and normalization are needed to unify data format and index unit, delete missing values to ensure data consistency and integrity. In the aspect of outlier detection, manual review is conducted to ensure that the data truly reflects the system behavior and avoids abnormal interference analysis.

[0061] 2. Data visualization Chart generation: Through data structure conversion + chart generation tools provided by llcBench, the bandwidth, CPI\IPC, cache hit rate of test results are presented to help quickly understand performance bottlenecks and test results.

[0062] 3. Performance index calculation and modeling Through comprehensive analysis of the collected performance data, CPI reflects the average delay of instruction execution, and the lower the value, the higher the pipeline efficiency; IPC measures the parallel processing capability of instructions, and the higher the value, the stronger the processor execution efficiency; cache hit rate represents the data access success rate, and the higher the value, the better the data locality and the lower the main memory dependence; cache bandwidth reflects the data throughput capacity per unit time, and the larger the value, the stronger the processor's support capacity for large-scale data load; running time is a direct performance indicator perceived by users, and the shorter the time, the higher the overall execution efficiency. Overall, low CPI, high IPC, high cache hit rate, large bandwidth and short running time are important manifestations of excellent processor performance, which can reflect the comprehensive processing capability of the processor in compute-intensive and memory-intensive scenarios. Combined with experimental data, comparisons of different types of data are made.

[0063] This embodiment mainly focuses on the design and implementation of the algorithm, and the core is to evaluate the CPU performance from multiple dimensions such as computing performance, memory access efficiency, and cache performance through two benchmark test tools LAMMPS and LLCBench.

[0064] Embodiment 2

[0065] A computer readable storage medium having a program stored thereon, the program being executed by a processor to implement the steps in the CPU performance test method in the Conda environment as described in embodiment 1.

[0066] Embodiment 3

[0067] An electronic device includes a memory, a processor, and a program stored on the memory and executable on the processor, and the processor executes the program to implement the steps in the CPU performance test method in the Conda environment as described in embodiment 1.< / pid>

Claims

1. A CPU performance testing method under the Conda environment, characterized in that, The steps include the following: (1) Environment construction Build a unified testing platform using the Conda environment, and install the necessary dependencies and libraries, including LAMMPS, LLCBench, Python, and perf. (2) Tool integration and testing (2-1) LAMMPS Benchmark Test: The test parameter script for the specified performance test uses perf to test the CPU's computing performance, including floating-point arithmetic capability, memory access efficiency, and multi-core parallel processing capability, by executing the LAMMPS standard benchmark test script. In addition, multi-threading and MPI modes were used to test CPU performance under different task sizes and thread numbers; performance results data were collected using the Jenkins tool. (2-2) LLC Bench Benchmark Test: The script specifies the test parameters for cache performance testing. Using the LLCBench tool, the standard CacheBench test module is executed to evaluate the bandwidth and latency characteristics of each level of the CPU cache, and analyze the impact of the cache architecture on the overall system performance, including cache access throughput, access response time, and data prefetching and reuse efficiency. In addition, using different vector lengths, access granularities, and thread counts, we tested the CPU's cache access performance under different data sizes and concurrency levels. Collect cached test result data using the LLCBench tool; (3) Data analysis and result verification By integrating data from LAMMPS and LLCBench, a multi-dimensional performance system is constructed, including L3 cache hit rate, cache bandwidth, and runtime from CPI, IPC, and Perf metrics. CPI reflects the average latency of instruction execution; a lower value indicates higher pipeline efficiency. IPC measures instruction parallel processing capability; a higher value indicates stronger processor execution efficiency. Cache hit rate represents the data access success rate; a higher value indicates better data locality and lower main memory dependency. Cache bandwidth reflects the data throughput per unit time; a larger value indicates stronger processor support for large-scale data loads. Runtime is a direct performance indicator perceived by the user; a shorter runtime indicates higher overall execution efficiency. Verify the accuracy and consistency of the data by repeating experiments to compare normalized data and conduct manual inspections to ensure the reliability of the test results; the above steps can complete the CPU performance test.

2. The CPU performance testing method under the Conda environment according to claim 1, characterized in that, In step (2-1), before executing the LAMMPS test script, the LAMMPS tool also includes: Specify the execution path, test particles, load mode, and test tasks for the LAMMPS test script; Create an execution project using the LAMMPS tool; The LAMMPS tool sets up coroutines based on the number of concurrent particles and the test duration, and on an event-driven architecture. The coroutine is invoked through the event loop to perform performance tests; The LAMMPS tool runs LAMMPS programs by executing LAMMPS test scripts based on the execution path, test particle scene, load mode, test task, and performance indicators in the execution project.

3. The CPU performance testing method under the Conda environment according to claim 2, characterized in that, In step (2-1), the LAMMPS tool performs performance tests based on the test parameters, and also includes: Monitor and control the execution of performance tests through the TOP interface.

4. The CPU performance testing method under the Conda environment according to claim 1, characterized in that, In step (2-1), after collecting performance result data using the Jenkins tool, the following steps are also included: The LAMMPS tool generates a performance test report based on the performance results data, which includes CPI, IPC, cache rate, and runtime. The performance test report includes performance metrics and error reports.

5. The CPU performance testing method under the Conda environment according to claim 1, characterized in that, In step (2-2), before executing the CacheBench test script, the LLCBench tool also includes: Specify the execution path, test granularity, access mode, and test tasks for the LLCBench test module; Create an execution project using the LLCBench tool; The LLCBench tool sets up the test process based on vector length, cache level, and number of threads, and drives the architecture based on the cache model. The test process is invoked through an internal loop mechanism to perform cache performance testing; The LLCBench tool runs the LLCBench core module by executing the CacheBench test program, based on the execution path, access vector, cache level, access mode, and performance metrics of the project.

6. The CPU performance testing method under the Conda environment according to claim 5, characterized in that, In step (2-2), the LLCBench tool performs cache performance testing based on the test parameters, and also includes: The execution of the cache test can be monitored and controlled through the TOP interface; It supports collecting read / write bandwidth and access latency metrics for each level of cache.

7. The CPU performance testing method under the Conda environment according to claim 1, characterized in that, In step (2-2), after collecting the cached test result data using the LLCBench tool, the following steps are also included: The LLCBench tool generates a cache performance test report based on the performance results data. The performance results data includes latency statistics for different cache levels, read and write bandwidth values, and analysis of the impact of access granularity on performance. The performance test report includes cache metric curves, hotspot level identification results, and error detection reports.

8. A computer-readable storage medium, characterized in that, It stores a program that, when executed by the processor, implements the steps of the CPU performance testing method in the Conda environment as described in any one of claims 1-7.

9. An electronic device, characterized in that, It includes a memory, a processor, and a program stored in the memory and executable on the processor, wherein the processor executes the program to implement the steps in the CPU performance testing method under the Conda environment as described in any one of claims 1-7.

Images