System and method for loading working condition data

Abstract

The invention discloses a system for loading working condition data, and the system comprises an initialization mapping module which is used for presetting the memory capacity of a sliding window, determining the memory capacity required by first mapping and the offset of the first mapping according to the memory capacity of working condition file data and the preset memory capacity of the sliding window, and executing file mapping operation to obtain a mapping pointer; and the window judgment module is used for judging whether all the data is in the mapping window according to the mapping pointer and the memory capacity of the data needing to be acquired currently, and if not, partially mapping the data and updating the mapping pointer until the data is loaded completely. The method solves the problems of high memory occupancy and system jamming when a plurality of channels operate a large data volume working condition at the same time, reduces CPU overhead through a memory mapping mechanism, dynamically manages memory mapping in combination with a sliding window mechanism, realizes efficient loading of the large data volume working condition, reduces system memory occupancy, and improves system performance. And the multi-channel operation stability and the resource utilization rate are improved.

Description

Technical Field

[0001] The technical field of this invention is operating system memory management technology, specifically referring to a system and method for loading operating condition data. Background Technology

[0002] In the field of battery performance testing, especially in the testing of power batteries for new energy vehicles, operating condition data (such as current and voltage change data under simulated electric vehicle acceleration and braking scenarios) is crucial for evaluating battery performance. Current testing systems typically employ a three-tier architecture consisting of a host computer, a mid-level computer (embedded controller), and a lower-level computer (actuator). The existing methods for loading and running operating condition data generally involve: process issuance and data storage, loading and execution of operating conditions, and data transmission and requesting subsequent data, repeating the request until completion. Specifically: First, the entire test process file is issued from the host computer to the mid-level computer. After receiving the file containing the operating condition data, the mid-level computer uses specialized parsing instructions to read and store each operating condition data entry sequentially in its local file system. When the test process reaches a specific operating condition step, the mid-level computer loads the entire corresponding operating condition data file into memory. Based on the execution progress, the mid-level computer sends the operating condition data loaded into memory to the lower-level computer for execution as needed (usually a specified number of entries) via a communication protocol (such as CAN bus). After the lower-level machine finishes executing the currently received instruction, it requests subsequent data from the middle-level machine, repeating the above steps (sending specified data, lower-level machine execution, and lower-level machine requesting new data) until all data for this working condition has been executed.

[0003] However, existing technologies can generally meet the requirements when the data volume is small or the number of test channels running simultaneously is limited. However, when faced with large data volumes and the demands of modern testing with high concurrency and multiple channels, significant drawbacks and limitations exist, leading to excessive memory consumption. Since each data point typically contains structured numerical information such as time, current, and power, loading the entire data point file means the host computer needs to maintain a complete copy of the file in memory for each running test channel. For example, a file containing 500,000 data points (approximately 4MB) with 30 channels running simultaneously will consume about 120MB of memory. For resource-constrained embedded host computer systems, available memory is usually limited, and such a large memory footprint can quickly exhaust system memory, severely limiting the maximum number of test channels that can run simultaneously, causing system lag and slow response. However, expanding hardware memory to meet these demands would significantly increase hardware costs and development / maintenance time. Traditional file reading methods involve disk I / O operations and typically require two data copies: from the disk to the kernel buffer, and then from the kernel buffer to the application's (intermediate computer software's) user space buffer. This process consumes significant CPU and system I / O resources, reducing overall system efficiency. Furthermore, traditional file reading methods have poor scalability; their memory and CPU consumption increases dramatically with the volume of operating data and the number of running channels, making them unsuitable for supporting larger-scale and more complex battery testing scenarios. Summary of the Invention

[0004] The purpose of this invention is to provide a system and method for loading operational data. This invention avoids multiple data copies as in traditional methods by directly mapping files to the application's address space, thereby reducing CPU and memory overhead. Furthermore, by combining on-demand loading and data block processing strategies, memory usage can be further reduced, improving system scalability. This approach not only significantly improves the operating efficiency of embedded mid-level computer systems but also supports larger-scale testing scenarios without significantly increasing hardware resources, effectively reducing the overall cost of system design and maintenance.

[0005] To achieve this objective, the present invention provides a system for loading operating condition data, comprising: The initialization mapping module is used to preset the sliding window memory capacity, determine the memory capacity required for the first mapping and the offset of the first mapping based on the memory capacity of the working condition file data and the preset sliding window memory capacity, and perform file mapping operation based on the memory capacity required for the first mapping and the offset of the first mapping to obtain the mapping pointer; The window judgment module is used to determine whether all the data to be acquired in the current working condition file can be mapped into the current sliding window based on the mapping pointer and the memory capacity of the data to be acquired in the current working condition file. If the judgment condition is met, the data to be acquired in the current working condition file is mapped into the current sliding window, and all the data to be acquired in the current working condition file is loaded. If the judgment condition is not met, the data that needs to be acquired from the current working condition file is mapped to the current mapping sliding window according to the set conditions to obtain the mapped offset. After the current mapping sliding window finishes reading the data, it is released, and the mapping pointer is updated according to the mapped offset. Based on the updated mapping pointer and the remaining data that needs to be acquired from the current working condition file excluding the mapped data, it is determined whether the remaining data that needs to be acquired from the current working condition file can be fully stored in the released sliding window. The mapping process is repeated until all the data that needs to be acquired from the current working condition file is loaded.

[0006] Preferably, the obtained mapped offset is the tail of the mapped data in the sliding window before the sliding window is released.

[0007] Preferably, the offset of the initial mapping is zero.

[0008] Preferably, the method for performing the file mapping operation to obtain the mapping pointer includes: Obtain the file descriptor of the operating condition file, invoke the operating system's memory mapping mechanism, establish a memory mapping relationship, input the file descriptor, the offset of the first mapping, and the memory capacity required for the first mapping, the operating system directly maps the operating condition file data to the process's address space mapping area, and returns a mapping pointer, which points to the starting address of the mapping area.

[0009] Preferably, the sliding window memory size is an integer multiple of the system page memory size.

[0010] Preferably, the system architecture includes multiple sliding windows, each sliding window has a dedicated running channel, each running channel corresponds to a working condition file, multiple working condition files are independently mapped to multiple running channels, and different sliding windows are independent of each other. The operating system uses the memory management unit to map the data that different working condition files need to obtain to different sliding windows.

[0011] Preferably, the memory capacity required for the first mapping is determined by the data memory of the operating condition file and the memory capacity of the preset sliding window. The smaller of the two is selected as the memory capacity required for the first mapping.

[0012] The beneficial effects of this invention are as follows: This invention proposes a system for loading operational data. By innovatively combining a memory mapping mechanism and a sliding window mechanism, it solves the key problems of high system memory consumption, high CPU resource consumption, and limited number of channels when multiple channels are running large amounts of operational data simultaneously, significantly improving the performance and reliability of embedded systems. Through the memory mapping mechanism, operational data is directly mapped to the process memory address space, requiring only one memory copy process. This effectively avoids the double copying overhead of traditional file reading methods, which involves copying data from disk to kernel buffer and then from kernel buffer to user space, significantly reducing CPU utilization and system resource consumption, and improving data loading efficiency. Through the sliding window mechanism, data blocks are dynamically mapped and released, retaining only the currently needed data. In memory, the system automatically slides and remaps the window when data reading is complete or nearing completion, ensuring that memory usage remains stable within tens of pages, thus avoiding system memory overflow and abnormal lag caused by large data volumes. For multi-channel parallel processing scenarios, an independent sliding window management strategy is adopted, with each channel's condition file mapped to an independent window, supporting unlimited expansion of the number of channels, enhancing the system's scalability and stability, while reducing hardware memory expansion requirements and lowering costs. By reducing the number of memory copies and optimizing memory usage, this invention enables efficient loading of massive amounts of data (such as millions of condition records) on resource-constrained embedded mid-level machines (such as Linux systems), improving the accuracy and continuity of battery testing processes, and providing reliable technical support for large-scale battery performance evaluation. Attached Figure Description

[0013] Figure 1 This is a schematic diagram of the structure of the present invention; Figure 2 This is a schematic diagram of the process of the present invention. Detailed Implementation

[0014] To make the objectives, technical solutions, and advantages of the embodiments of the present invention clearer, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only a part of the embodiments of the present invention, not all of them. Therefore, the following detailed description of the embodiments of the present invention provided in the accompanying drawings is not intended to limit the scope of the claimed invention, but merely to represent selected embodiments of the invention. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without inventive effort are within the scope of protection of the present invention.

[0015] The present invention will be further described in detail below with reference to the accompanying drawings and specific embodiments: Example 1 A system for loading operating condition data, such as Figure 1As shown, it includes: The initialization mapping module is used to preset the sliding window memory capacity, determine the memory capacity required for the first mapping and the offset of the first mapping based on the memory capacity of the working condition file data and the preset sliding window memory capacity, and perform file mapping operation based on the memory capacity required for the first mapping and the offset of the first mapping to obtain the mapping pointer; The window judgment module is used to determine whether all the data to be acquired in the current working condition file can be mapped into the current sliding window based on the mapping pointer and the memory capacity of the data to be acquired in the current working condition file. If the judgment condition is met, the data to be acquired in the current working condition file is mapped into the current sliding window, and all the data to be acquired in the current working condition file is loaded. If the judgment condition is not met, the data that needs to be acquired from the current working condition file is mapped to the current mapping sliding window according to the set conditions to obtain the mapped offset. After the current mapping sliding window finishes reading the data, it is released, and the mapping pointer is updated according to the mapped offset. Based on the updated mapping pointer and the remaining data that needs to be acquired from the current working condition file excluding the mapped data, it is determined whether the remaining data that needs to be acquired from the current working condition file can be fully stored in the released sliding window. The mapping process is repeated until all the data that needs to be acquired from the current working condition file is loaded.

[0016] Some implementation schemes of the loading condition data system of this invention directly map condition files to the process address space, avoiding the two memory copies (disk-kernel-user space) of traditional file reading, significantly reducing CPU overhead. A sliding window mechanism dynamically manages the mapping area, retaining only the currently processed data block (e.g., the window size is an integer multiple of the system page). Upon completion of reading or nearing completion, the window is released and remapped to handle subsequent data, compressing memory usage to a fixed window size and avoiding excessive single-channel memory load in traditional solutions. A window-based decision module dynamically segments the data loading process, ensuring independent operation of each channel and preventing memory overlap. This supports unlimited expansion of the number of channels while maintaining the independence of multiple channels.

[0017] There are several preferred technical solutions that can be implemented based on the above-described technical solutions of the present invention, as detailed below.

[0018] In this embodiment, the system runs on a mid-level computer, which is an embedded Linux operating system. The host computer sends the process file and operating condition file to the mid-level computer via Ethernet using the TCP protocol (Transmission Control Protocol). When the operating condition step is reached, the operating condition data is loaded and sent to the lower-level computer via the CAN protocol (Controller Area Network) to execute the operating condition command.

[0019] In this embodiment, the operating condition file is a carrier file that stores structured operating condition data in battery testing scenarios. Each data entry consists of 8 bytes in a fixed format, such as 4 bytes of current or power value and 4 bytes of time value (timestamp or duration). Its data is used, for example, to simulate data in scenarios such as electric vehicle acceleration (high current discharge) and braking (energy recovery charging). The operating condition file is stored in binary or structured text file format (such as one complete operating condition record per 8 bytes) to simulate the battery's operating status under different usage scenarios and to evaluate performance, lifespan, and safety.

[0020] In this embodiment, the sliding window is a dynamic memory mapping management mechanism that reads the operating condition file through a fixed-size memory block; it is a dynamically moving data window that slides sequentially along the operating condition file, retaining only the currently processed subset of data; when data is read to the window boundary, memory is released and subsequent data is remapped, and data is loaded and released on demand.

[0021] In some embodiments of the present invention, the judgment condition is: if all the data that the current operating condition file needs to acquire can be mapped into the currently mapped sliding window, the judgment condition is satisfied; if the data that the current operating condition file needs to acquire cannot be mapped into the currently mapped sliding window, the judgment condition is not satisfied.

[0022] In some embodiments of the present invention, the file mapping operation is performed based on the memory capacity required for the first mapping and the offset of the first mapping, and the resulting mapping pointer is the starting position of the sliding window.

[0023] For sliding windows, some optimized technical solutions include: the obtained mapped offset is the tail of the mapped data of the sliding window before the sliding window is released.

[0024] In some embodiments of the present invention, the end of the window before release is used as the new mapping starting point, rather than an arbitrary position, to ensure seamless data connection, prevent misalignment or loss of working condition data, and improve execution reliability.

[0025] For the offset of the initial mapping, some optimized techniques include setting the offset of the initial mapping to zero.

[0026] In some embodiments of the present invention, the initial mapping offset is fixed at the file header, that is, the offset is equal to 0, which avoids complex positioning calculations, reduces implementation complexity, and reduces code redundancy.

[0027] In some implementation schemes, the operating condition data, including but not limited to the operating condition data mainly involved in battery testing scenarios, is structured data.

[0028] In some preferred embodiments of this invention, when performing file mapping operations, the specific process for obtaining the mapping pointer is as follows: Obtain the file descriptor of the working condition file, call the operating system's memory mapping mechanism to establish a memory mapping relationship, input the file descriptor, the offset of the first mapping, and the memory capacity required for the first mapping. The operating system kernel directly maps the file content to the process's address space mapping area and returns a mapping pointer (PTR) that points to the starting address of the mapping area.

[0029] In this embodiment, the starting address is the virtual address space start pointer returned by the operating system after performing the memory mapping operation (mmap), pointing to the first byte of the mapped region. It serves as the entry point for reading operational data, the starting point for loading the operational file into the process address space; it also serves as the anchor point for moving the sliding window, updating as the sliding window is released and remapped.

[0030] In some embodiments of the present invention, a mapping relationship is established between a file descriptor and the mmap (Memory Mapping) call to directly obtain the mapping pointer (PTR) managed by the operating system, ensuring compatibility with different embedded Linux kernels and enhancing the portability of the solution.

[0031] In this embodiment, the memory capacity of the working condition file data that needs to be acquired is calculated and compared with the currently mapped sliding window. If the memory capacity of the working condition file data is less than or equal to the memory capacity of the currently mapped sliding window, the judgment condition is met; if the memory capacity of the working condition file data is greater than the memory capacity of the currently mapped sliding window and cannot be fully mapped into the currently mapped sliding window, the judgment condition is not met. If the judgment condition is not met, then the data that needs to be acquired from the current working condition file will be mapped to a portion of the sliding window with a memory size equal to the set sliding window memory capacity. The formula for calculating the memory size of the remaining data to be acquired from the current working condition file, excluding the mapped portion, is as follows: The mapped portion of data = (the logical sequence number of the data to be obtained in the current working condition file in the file - 1) / sliding window memory size) × sliding window memory size × 8; The remaining data to be acquired = the data to be acquired in the current operating condition file - the data that has already been mapped.

[0032] In some embodiments of the present invention, the remaining data volume (mapped portion = processed logical sequence number × window size) is calculated by formula, and the next mapping range is dynamically adjusted in combination with the total file size to avoid over-mapping or data omission and optimize memory reuse efficiency.

[0033] Regarding the memory size of the sliding window, some optimization techniques include: the sliding window memory size should be an integer multiple of the system page memory size. A system page is the smallest unit of physical and virtual memory managed by the operating system, and its size is a fixed-size memory block determined by the CPU architecture and operating system configuration. The types of system page sizes supported by the CPU's memory management unit (MMU) module are determined by the hardware itself, such as 4KB / 16KB / 64KB. At the operating system configuration level, the kernel compilation allows selection of which page size to use, such as using a default page size of 4KB. There is a mandatory constraint between the system page and the sliding window memory size, requiring that the mapped region must be page-aligned; otherwise, mapping will fail. If the sliding window size is not an integer multiple, it will cause cross-page access, increasing the number of table lookups by the MMU. Furthermore, an integer multiple of the sliding window size ensures that the new offset remains aligned with the page boundary during sliding, effectively maintaining the continuity of the sliding.

[0034] In some embodiments of the present invention, the window size is forced to be an integer multiple of the system page size (e.g., 4KB / 16KB), the characteristics of the MMU (Memory Management Unit) are used to reduce memory fragmentation and improve mapping efficiency (mmap operates on a page-by-page basis). At the same time, different CPU architectures are dynamically adapted through system-level functions (e.g., getpagesize) to ensure stability in embedded resource-constrained scenarios.

[0035] In this embodiment, the system architecture includes multiple sliding windows, each sliding window has a dedicated running channel, each running channel corresponds to a working condition file, and multiple working condition files are independently mapped to multiple running channels. Different sliding windows are independent of each other. The operating system (e.g., Linux, Windows, macOS, etc.) uses a memory management unit to map the data that different working condition files need to obtain to different sliding windows.

[0036] In some embodiments of the present invention, the operating system allocates independent sliding windows for different working condition files to avoid data pollution between channels (such as data from working condition A being mistakenly written into the window of working condition B), while the MMU isolates memory access to ensure the security of multi-task concurrency.

[0037] In some preferred embodiments of the present invention, when determining the memory capacity required for the first mapping, the memory capacity required for the first mapping is determined by the data memory of the operating condition file and the memory capacity of the preset sliding window. The smaller of the two is selected as the memory capacity required for the first mapping.

[0038] In some embodiments of the present invention, each piece of operating condition data consists of eight bytes: a 4-byte current or power field, a 4-byte time field, and is parsed according to the 8-byte structure.

[0039] In some embodiments of the present invention, the sliding window mechanism means that when the mapped memory data is read (mapped) or about to be read, the memory of the sliding window is released, and the end of the previously mapped memory is used as the starting point for remapping new page memory. This process is repeated until the file memory is read completely. For example, if 1024 work cases need to be mapped at a time, that is, 1024×8 memory is mapped, and 20 work cases are read each time, the first time the starting number is 1, and 20 cases are read. The second starting number is 21, and 20 records are read. … The starting number for the Nth iteration is 1021. After reading 20 records, only 3 records remain (1024-1021). Since there are fewer than 20 records, only the remaining 3 records are read. Once the reading is complete, the memory of the sliding window is released.

[0040] In some preferred embodiments of the present invention, when performing file mapping operations, each read operation is performed with the mapped memory starting address being valid.

[0041] In some embodiments of the present invention, by taking the smaller value between the file size and the preset window during the initial mapping, it is possible to effectively prevent small files from being mapped to excessively large windows, thus avoiding waste, or large files from overflowing during initial loading, thereby achieving on-demand resource allocation.

[0042] In this embodiment, multiple operating condition files are synchronized and mapped according to the following principles: 1. One-to-one independent mapping principle: Each working condition file has its own dedicated running channel, each channel is assigned an independent sliding window, and the implementation logic structure for loading working condition data in each working condition file is the same, all of which must pass through the system's initialization mapping module and window judgment module.

[0043] 2. Memory Management Unit Isolation: The operating system (such as embedded Linux) allocates isolated memory address space for each sliding window through the MMU (Memory Management Unit) to prevent data corruption.

[0044] 3. Parallel loading principle: The mapping, sliding, and releasing of windows are completely independent, supporting an unlimited number of running channels.

[0045] Example 2 A method for loading operating condition data, comprising: The memory capacity of the sliding window is preset. The memory capacity required for the first mapping and the offset of the first mapping are determined based on the memory capacity of the working condition file data and the preset sliding window memory capacity. The file mapping operation is performed based on the memory capacity required for the first mapping and the offset of the first mapping to obtain the mapping pointer. Based on the mapping pointer and the memory capacity of the current working condition file data to be acquired, determine whether all the data to be acquired in the current working condition file can be mapped into the current mapping sliding window. If the judgment condition is met, then the data to be acquired in the current working condition file is mapped into the current mapping sliding window, and all the data to be acquired in the current working condition file is loaded. If the judgment condition is not met, the data that needs to be acquired from the current working condition file is mapped to the current mapping sliding window according to the set conditions to obtain the mapped offset. After the current mapping sliding window finishes reading the data, it is released, and the mapping pointer is updated according to the mapped offset. Based on the updated mapping pointer and the remaining data that needs to be acquired from the current working condition file excluding the mapped data, it is determined whether the remaining data that needs to be acquired from the current working condition file can be fully stored in the released sliding window. The mapping process is repeated until all the data that needs to be acquired from the current working condition file is loaded.

[0046] The implementation steps for loading operating condition data are as follows: The logical structure is as follows Figure 2 As shown, the details are as follows: 1) The default size of the sliding window to be mapped is WINDOW_SIZE. Open the work condition file and take the minimum value between the number of work condition records and WINDOW_SIZE as the initial mapping size. The initial mapping file offset is zero, that is, the current index is zero, and the index is used as the right boundary of the mapping area.

[0047] 2) Perform file mapping operations based on the size and offset mapped in step 1 to obtain the mapping pointer PTR.

[0048] 3) Obtain the working condition from the mapping area based on the starting number and number of working conditions to be obtained: a. If the starting number (the logical sequence number of the working condition data entry, starting from 1, used to identify the position of the data in the file) + the number of working condition file data entries to be obtained is less than or equal to the current index, it means that the data to be obtained falls within the current mapping window. At this time, by adding the starting number to PTR and taking the modulo of WINDOW_SIZE, the offset position of the data to be obtained is obtained, and the data to be obtained is started from this position. b. When the starting number plus the number of data entries in the working condition file to be acquired is greater than the current index, it means that only part of the data to be acquired is in the current window, while the other part is outside the window. In this case, acquire the data within the window first. c. Release the PTR, restart the mapping, move the window forward, and the mapping offset relative to the file is the current index. The remaining data will be retrieved in the new window.

[0049] d. Repeat steps a, b, and c above to obtain the operating conditions until all the data required for the current operating condition file has been loaded.

[0050] Example 3 A computer program product includes a computer program, characterized in that, when the computer program is executed by a processor, it implements the steps of the method described in Embodiment 2.

[0051] The contents not described in detail in this specification are existing technologies known to those skilled in the art.

Claims

1. A system for loading operating condition data, characterized in that, It includes: The initialization mapping module is used to preset the sliding window memory capacity, determine the memory capacity required for the first mapping and the offset of the first mapping based on the memory capacity of the working condition file data and the preset sliding window memory capacity, and perform file mapping operation based on the memory capacity required for the first mapping and the offset of the first mapping to obtain the mapping pointer; The window judgment module is used to determine whether all the data to be acquired in the current working condition file can be mapped into the current sliding window based on the mapping pointer and the memory capacity of the data to be acquired in the current working condition file. If the judgment condition is met, the data to be acquired in the current working condition file is mapped into the current sliding window, and all the data to be acquired in the current working condition file is loaded. If the judgment condition is not met, the data that needs to be acquired in the current working condition file is mapped to the current mapping sliding window according to the set conditions to obtain the offset after mapping. After the current mapping sliding window finishes reading the data, it is released and the mapping pointer is updated according to the mapping offset. Based on the updated mapping pointer and the remaining data that needs to be acquired in the current working condition file excluding the mapped data, it is determined whether the remaining data that needs to be acquired in the current working condition file can be fully stored in the released sliding window. The mapping process is repeated until all the data that needs to be acquired in the current working condition file is loaded.

2. The system for loading operating condition data according to claim 1, characterized in that: The offset after mapping is the end of the mapped data in the sliding window before it is released.

3. The system for loading operating condition data according to claim 1, characterized in that: The initial mapping offset is zero.

4. The system for loading operating condition data according to claim 1, characterized in that: The methods for obtaining the mapping pointer by performing the file mapping operation include: Obtain the file descriptor of the operating condition file, invoke the operating system's memory mapping mechanism, establish a memory mapping relationship, input the file descriptor, the offset of the first mapping, and the memory capacity required for the first mapping, the operating system directly maps the operating condition file data to the process's address space mapping area, and returns a mapping pointer, which points to the starting address of the mapping area.

5. The system for loading operating condition data according to claim 1, characterized in that: Calculate the memory capacity of the current working condition file data that needs to be acquired, and compare it with the memory capacity of the currently mapped sliding window. If the memory capacity of the working condition file data is less than or equal to the memory capacity of the currently mapped sliding window, the judgment condition is met; if the memory capacity of the working condition file data is greater than the memory capacity of the currently mapped sliding window, and cannot be fully mapped into the currently mapped sliding window, the judgment condition is not met. If the judgment condition is not met, then the data that needs to be acquired from the current working condition file will be mapped to a portion of the sliding window with a memory size equal to the set sliding window memory capacity. The formula for calculating the memory size of the remaining data to be acquired from the current working condition file, excluding the mapped portion, is as follows: The mapped portion of data = (the logical sequence number of the data to be obtained in the current working condition file in the file - 1) / (sliding window memory size) × sliding window memory size × 8; The remaining data to be acquired = the data to be acquired in the current operating condition file - the data that has already been mapped.

6. The system for loading operating condition data according to claim 1, characterized in that: The memory size of the sliding window is an integer multiple of the system page memory size.

7. A system for loading operating condition data according to claims 1-6, characterized in that: The system architecture includes multiple sliding windows, each with its own dedicated running channel. Each running channel corresponds to a working condition file, and multiple working condition files are independently mapped to multiple running channels. Different sliding windows are independent of each other. The operating system uses the memory management unit to map the data that different working condition files need to obtain to different sliding windows.

8. The system for loading operating condition data according to claim 1, characterized in that: The memory capacity required for the first mapping is determined by the data memory of the operating condition file and the memory capacity of the preset sliding window. The smaller of the two is selected as the memory capacity required for the first mapping.

9. A method for loading operating condition data, characterized in that, It includes: The memory capacity of the sliding window is preset. The memory capacity required for the first mapping and the offset of the first mapping are determined based on the memory capacity of the working condition file data and the preset sliding window memory capacity. The file mapping operation is performed based on the memory capacity required for the first mapping and the offset of the first mapping to obtain the mapping pointer. Based on the mapping pointer and the memory capacity of the current working condition file data to be acquired, determine whether all the data to be acquired in the current working condition file can be mapped into the current mapping sliding window. If the judgment condition is met, then the data to be acquired in the current working condition file is mapped into the current mapping sliding window, and all the data to be acquired in the current working condition file is loaded. If the judgment condition is not met, the data that needs to be acquired in the current working condition file is mapped to the current mapping sliding window according to the set conditions to obtain the offset after mapping. After the current mapping sliding window finishes reading the data, it is released and the mapping pointer is updated according to the mapping offset. Based on the updated mapping pointer and the remaining data that needs to be acquired in the current working condition file excluding the mapped data, it is determined whether the remaining data that needs to be acquired in the current working condition file can be fully stored in the released sliding window. The mapping process is repeated until all the data that needs to be acquired in the current working condition file is loaded.

10. A computer program product, comprising a computer program, characterized in that, When the computer program is executed by a processor, it implements the steps of the method of claim 9.

Images