A software-defined reflective memory emulation resource pool dynamic reconstruction method and system

Abstract

The application relates to the computer technical field and discloses a software-defined reflective memory simulation resource pool dynamic reconstruction method and system, aiming to solve the problems of fixed resource allocation, inflexible node cooperation, insufficient heterogeneous resource management capability and missing intelligent mapping mechanism in the prior art. The method comprises the following steps: constructing a software-defined reflective memory simulation resource virtualization abstraction layer, and uniformly mapping physical hardware resources into virtualization resource objects; establishing a simulation resource pool management system based on consistency hashing and distributed coordination service; and realizing the elastic scaling of runtime resources through a dynamic reconstruction engine. The system comprises a virtualization abstraction layer, a distributed resource pool management module, an intelligent scheduling optimization engine, a heterogeneous resource management framework and a multi-level fault tolerance protection module. The application can realize the runtime dynamic reconstruction of simulation resources, significantly improve the unified management capability of heterogeneous resources and the resource utilization efficiency, and guarantee the high-reliability continuous operation of a simulation system.

Description

Technical Field

[0001] This invention belongs to the field of computer technology, specifically relating to a method and system for dynamic reconstruction of a software-defined reflection memory simulation resource pool. Background Technology

[0002] With the rapid development of modern simulation technology, high-performance real-time simulation systems have been widely used in key fields such as aerospace, industrial control, and weaponry. These systems have extremely high requirements for the real-time and deterministic nature of data interaction, typically needing to complete the synchronous transmission and processing of large-scale data at the millisecond or even microsecond level. Reflective memory, as a high-speed shared memory technology, implements memory data mirroring between multiple nodes through hardware, providing deterministic data forwarding latency, and has become one of the core supporting technologies for real-time simulation systems.

[0003] Software-defined technology, as a novel computing paradigm, abstracts hardware resources into software-schedulable virtualized resources, enabling flexible configuration and dynamic allocation of computing, storage, and network resources. In recent years, it has achieved significant results in fields such as cloud computing and edge computing. Introducing the software-defined concept into the field of reflective memory simulation, and constructing dynamically reconfigurable simulation resource pools, has become an important technological direction for improving the resource utilization and configuration flexibility of simulation systems.

[0004] However, existing reflective memory simulation systems still face numerous technical limitations in practical applications: First, resource allocation methods are relatively fixed, requiring pre-configuration of memory and computing resources for each node before simulation tasks begin, lacking the ability to dynamically adjust at runtime, making it difficult to adaptively allocate resources when simulation task load changes; second, inter-node collaboration mechanisms are not flexible enough, requiring complex manual configuration and debugging when adding or removing simulation nodes, limiting system scalability and fault tolerance; third, existing solutions lack unified management capabilities for heterogeneous simulation resources, making it difficult to achieve efficient unified scheduling and collaborative work for computing resources of different types and architectures; finally, there is a lack of intelligent mapping mechanisms between simulation resource configuration and business requirements, making it impossible to dynamically optimize resource configuration strategies based on the real-time status of simulation tasks, resulting in low resource utilization efficiency and increased operation and maintenance costs. These problems severely restrict the application performance of reflective memory simulation systems in complex scenarios, necessitating the use of dynamic reconfiguration technology to achieve flexible configuration and optimized management of the simulation resource pool. Summary of the Invention

[0005] To achieve the above objectives, the technical solution adopted by the present invention is as follows: A method for dynamic reconfiguration of a software-defined reflective memory simulation resource pool includes the following specific steps: Step (1) Constructing a software-defined reflective memory simulation resource virtualization abstraction layer: Deeply virtualizing and abstracting physical reflective memory hardware resources, uniformly mapping computing resources, storage resources, and network resources into software-defined virtualized resource objects, establishing a resource topology model and state awareness mechanism, and realizing transparent upper-layer calls to hardware resources; Step (2) Establishing a distributed simulation resource pool management system: Based on the consistent hashing algorithm and distributed coordination service, constructing a simulation resource pool with elastic scalability, deploying a dynamic reconfiguration engine and resource scheduler within the resource pool, supporting automatic discovery, registration, and exit of nodes, and realizing centralized management and distributed collaboration of simulation resources; Step (3) Implementing runtime dynamic resource reconfiguration: The dynamic reconfiguration engine monitors the load status and resource usage of simulation tasks in real time, and automatically performs resource migration according to the preset reconfiguration strategy and real-time analysis results. 1. Load balancing and capacity adjustment, supporting hot-swappable incremental or decremental resource configuration to ensure continuous execution of simulation tasks; Step (4) Deploy intelligent resource scheduling and optimization mechanism: Based on long-term series prediction model and reinforcement learning algorithm, construct resource demand prediction model and dynamic optimization decision engine, intelligently generate resource configuration optimization strategy according to the real-time status and historical operation characteristics of simulation tasks, and maximize resource utilization efficiency; Step (5) Build a unified management framework for heterogeneous simulation resources: Design cross-architecture resource abstraction interface and unified scheduling protocol, support the access of computing resources of different types and architectures to the resource pool, realize transparent management and collaborative scheduling of heterogeneous resources, and break down resource architecture barriers; Step (6) Implement multi-level fault tolerance and self-healing mechanism: Adopt checkpoint saving and state recovery technology, combined with master-slave switching and load transfer strategy, build a multi-level fault tolerance protection system, automatically trigger the self-healing process when a node fails, and ensure the reliable operation of the simulation system.

[0006] Preferably, the virtualization abstraction layer in step (1) adopts a layered architecture design, including a hardware abstraction layer, a resource management layer and an interface service layer. The hardware abstraction layer is responsible for uniformly encapsulating the reflection memory hardware devices of different manufacturers into standardized virtual resource units. The resource management layer realizes the allocation, recycling and scheduling of resources. The interface service layer provides a northbound standardized call interface and supports the access of multiple programming languages ​​and development environments.

[0007] Preferably, in step (2), the simulation resource pool adopts a master-slave architecture design. The resource pool manager, as the master node, is responsible for maintaining the global resource view and scheduling decisions. The distributed coordination service adopts a consistency module based on the Raft protocol to ensure consistent synchronization of resource status information among all nodes. The resource pool size can be dynamically expanded to a preset number of nodes.

[0008] Preferably, in step (3), the dynamic reconfiguration engine adopts an event-driven triggering mechanism. The reconfiguration triggering conditions include resource utilization threshold, task response latency threshold and load change rate threshold. The reconfiguration operations include resource elastic scaling, task migration and topology adjustment. It supports reconfiguration response time at preset time levels, and the task interruption time during the reconfiguration process is less than the preset time threshold.

[0009] Preferably, in step (4), the resource demand prediction model adopts a long short-term memory network based on the attention mechanism. The input features include historical resource utilization rate, task feature vector, time series features and environmental parameters. The prediction window covers the resource demand for a preset time period. The prediction accuracy meets the preset accuracy requirements. The reinforcement learning decision engine adopts the deep Q network algorithm. The optimization objectives are system throughput, energy efficiency and task completion rate.

[0010] Preferably, in step (5), the heterogeneous resource unified management framework supports the hybrid access of multiple mainstream computing architectures, the cross-architecture resource abstraction interface adopts a unified resource description language, the resource scheduling protocol is compatible with multiple interconnection methods, and the heterogeneous resource scheduling delay meets the preset low latency requirements.

[0011] Preferably, the multi-level fault tolerance mechanism in step (6) includes three levels: node-level fault tolerance, task-level fault tolerance, and system-level fault tolerance. Node-level fault tolerance adopts real-time mirroring technology, task-level fault tolerance adopts checkpoint recovery technology, the checkpoint saving interval can be configured to a preset time interval range, the fault recovery time meets the preset fast recovery requirements, and the system availability reaches the preset high availability level.

[0012] Preferably, this method also includes a visualization monitoring and management module for the simulation resource pool, which displays the resource pool topology, node status, resource utilization, and task execution in real time, supports web-based remote management and configuration operations, and provides resource usage reports and performance analysis functions.

[0013] Preferably, this method also includes a resource quota management and billing mechanism, which supports dynamic quota allocation based on simulation task priority and resource usage, provides refined measurement and cost analysis of resource usage, and supports resource isolation and fair scheduling in multi-tenant scenarios.

[0014] Compared with the prior art, the present invention has the following beneficial effects: 1. Highly flexible dynamic resource reconfiguration capability: Breaking through the limitations of fixed resource allocation in traditional reflective memory simulation systems, the simulation resources can be dynamically adjusted at runtime through a software-defined virtualization abstraction layer and a dynamic reconfiguration engine. The resource elastic scaling response time reaches the preset response level, which significantly improves efficiency compared to the traditional static configuration method and effectively adapts to simulation task load fluctuation scenarios.

[0015] 2. Excellent heterogeneous resource unified management capability: Through cross-architecture resource abstraction interface and unified scheduling protocol, transparent management of computing resources of different types and architectures has been successfully achieved, breaking down resource architecture barriers. The scheduling latency of heterogeneous resources meets the preset low latency requirements, the types of resources that the system can support have increased significantly, and the applicability of the simulation system has been significantly expanded.

[0016] 3. Intelligent resource optimization and scheduling capabilities: Based on demand prediction using long short-term memory networks and a reinforcement learning decision engine, it achieves accurate prediction and dynamic optimization of simulation resource demand. The prediction accuracy meets the preset accuracy requirements, resource utilization efficiency is significantly improved, and operation and maintenance costs and energy consumption expenditures are effectively reduced.

[0017] 4. Highly reliable fault-tolerant and self-healing mechanism: A three-level fault-tolerant protection system at the node level, task level, and system level is constructed. The system availability reaches the preset high availability level, and the fault recovery time meets the preset rapid recovery requirements, ensuring the continuous and reliable operation of simulation tasks in key areas. The reliability is significantly improved compared with traditional solutions. Attached Figure Description

[0018] The accompanying drawings are provided to further illustrate the invention and form part of the specification. They are used in conjunction with embodiments of the invention to explain the invention and do not constitute a limitation thereof. In the drawings: Figure 1 This is a schematic diagram of the overall technical solution architecture of the software-defined reflection memory simulation resource pool dynamic reconstruction method proposed in this invention; Figure 2 This is a schematic diagram illustrating the core principle framework of the collaborative work between the virtualization abstraction layer and the dynamic reconstruction engine in this invention. Figure 3 This is a schematic diagram of the intelligent resource scheduling and optimization mechanism framework based on long short-term memory network and reinforcement learning algorithm in this invention; Figure 4 This is a schematic diagram of the overall architecture of the heterogeneous simulation resource unified management framework and multi-level fault-tolerant self-healing mechanism in this invention. Detailed Implementation

[0019] Example 1 This embodiment uses a software-defined reflective memory simulation resource pool dynamic reconstruction method and system as the core technical solution, and elaborates on the physical construction of the system architecture and the software and hardware collaborative workflow. This embodiment is applicable to high-performance real-time simulation systems in key fields such as aerospace, industrial control, and weaponry, and can realize flexible configuration, dynamic adjustment, and intelligent management of simulation resources.

[0020] I. System Architecture Construction The software-defined reflection memory simulation resource pool dynamic reconstruction system constructed in this invention adopts a layered design concept, comprising, from bottom to top, a physical hardware resource layer, a virtualization abstraction layer, a resource pool management layer, an intelligent scheduling layer, and an application service layer. Each layer interacts with the others through standardized interface protocols for data exchange and function calls, forming a complete resource management and service delivery system.

[0021] 1.1 Physical Hardware Resource Layer The physical hardware resource layer is the underlying infrastructure of the entire system, responsible for supporting various reflective memory hardware devices and computing resources. In this embodiment, the physical hardware resources include the following core components: The reflective memory network interface card, as the core communication device of the system, connects to the host computing node via a high-speed PCIe interface. Each reflective memory card has a built-in independent embedded processor and a high-speed SRAM storage array, achieving real-time data synchronization between multiple nodes through a hardware-level memory mirroring mechanism. In this embodiment, a reflective memory card supporting 32-node interconnection is selected, with 512MB of onboard high-speed storage media, data transmission latency of less than 500 nanoseconds, and network bandwidth of up to 160MB / s. The reflective memory card achieves physical connection between nodes through a dedicated fiber optic channel or high-speed copper cable, supporting ring, star, or hybrid topologies.

[0022] The computing resource nodes utilize a high-performance industrial server platform, equipped with multi-core, multi-threaded processors, large-capacity memory, and high-speed storage devices. In this embodiment, the computing nodes employ Intel Xeon Gold series processors with a clock speed exceeding 2.5GHz, supporting the AVX-512 vector operation instruction set. A single node can provide 128GB of DDR4 memory and 4TB of NVMe solid-state storage. Each computing node connects to a reflective memory card via a PCIe 3.0 x16 lane, ensuring high-speed data transmission. The computing node operating system uses a Linux kernel, optimized for real-time performance, with system scheduling latency controlled to within 10 microseconds.

[0023] The network infrastructure uses 10 Gigabit Ethernet switches as the management network plane, responsible for node management, configuration command issuance, and transmission of status monitoring data. In this embodiment, commercially available products supporting VLAN segmentation and QoS (Quality of Service) management are selected, with a port speed of 10Gbps and a switching capacity of 256Gbps. To ensure the reliability of the management network, the switches adopt a dual-machine hot standby architecture, implementing gateway redundancy through the VRRP protocol.

[0024] 1.2 Virtualization Abstraction Layer The virtualization abstraction layer is one of the core innovations of this invention. It uses deep virtualization technology to uniformly map physical hardware resources into software-definable virtualized resource objects. In this embodiment, the virtualization abstraction layer adopts a three-layer architecture design, including a hardware abstraction layer, a resource management layer, and an interface service layer.

[0025] The Hardware Abstraction Layer (HAL) is responsible for encapsulating reflective memory hardware devices from different manufacturers and models into standardized virtual resource units. This layer employs a unified device driver framework, automatically identifying and initializing connected reflective memory hardware devices through a plug-and-play mechanism. Internally, the HAL comprises three sub-components: a device discovery module, a driver adaptation module, and a resource mapping module. The device discovery module uses PCIe configuration space scanning and MAC address recognition technology to automatically detect reflective memory cards. The driver adaptation module provides differentiated driver interfaces for the hardware characteristics of different manufacturers, shielding hardware detail differences. The resource mapping module divides the physical memory address space into multiple virtual memory regions, each corresponding to a virtual resource unit, supporting flexible configuration of attributes such as memory capacity, access bandwidth, and priority.

[0026] The resource management layer implements the allocation, reclamation, and scheduling functions of virtualized resources. This layer employs a weighted fair scheduling algorithm, supporting three allocation modes: resource reservation, resource constraint, and resource sharing. The resource reservation mode guarantees that a virtual resource unit receives its reserved minimum resource quota; the resource constraint mode constrains the maximum resource usage of a virtual resource unit; and the resource sharing mode allows idle resources to be dynamically allocated among multiple virtual resource units. The resource management layer also maintains a global resource status database, recording the attribute information, current allocation status, and usage statistics of all virtual resource units, providing data support for resource scheduling decisions at the upper layer.

[0027] The interface service layer provides standardized northbound call interfaces, supporting access from multiple programming languages ​​and development environments. This layer is built upon two interface protocols: RESTful API and gRPC. RESTful API is used for management and configuration operations, while gRPC is used for high-frequency data interaction operations. The interface service layer defines a complete set of resource operation interfaces, including resource creation, resource query, resource modification, resource release, and resource migration. To facilitate application integration, this layer also provides SDK development packages in Python, C++, and Java, encapsulating the underlying communication details and providing simple and easy-to-use programming interfaces.

[0028] 1.3 Distributed Simulation Resource Pool Management System The distributed simulation resource pool management system is built on a consistent hashing algorithm and a distributed coordination service, possessing elastic scalability and high availability. A dynamic reconfiguration engine and resource scheduler are deployed within the resource pool, supporting automatic node discovery, registration, and exit, enabling centralized management and distributed collaboration of simulation resources.

[0029] The Resource Pool Manager, as the core control component of the entire resource pool, runs on a dedicated high-availability server cluster, employing a primary-backup dual-machine hot standby architecture to ensure the reliability of the control plane. The Resource Pool Manager is responsible for maintaining a global resource view, including the resource capacity, current load, running status, and topology information of all compute nodes. This component uses a distributed consistency protocol to guarantee data consistency across all management nodes. When the primary node fails, the backup node can switch roles within seconds and continue providing services.

[0030] The distributed coordination service employs a consistency module based on the Raft protocol to achieve strong consistency synchronization of resource status information across all nodes. In this embodiment, the distributed coordination service consists of 5 nodes deployed at different physical locations within the resource pool. The Raft protocol, through log replication and leader election mechanisms, ensures that the system can still provide services normally even if up to two nodes fail. The distributed coordination service provides core functionalities such as distributed locks, configuration management, and member changes, forming the foundation for the elastic scaling of the resource pool.

[0031] The dynamic reconfiguration engine is the core component for dynamically adjusting runtime resources, employing an event-driven triggering mechanism. Internally, it comprises three sub-components: a status monitoring module, a decision analysis module, and an execution scheduling module. The status monitoring module collects real-time data on node load, memory usage, network bandwidth, and task queue length through agents deployed on each compute node. The data collection frequency is configurable, with a default value of once per second. The decision analysis module determines whether to trigger resource reconfiguration operations based on preset reconfiguration strategies and real-time analysis results. Reconfiguration triggering conditions include resource utilization thresholds, task response latency thresholds, and load change rate thresholds. The execution scheduling module is responsible for executing specific reconfiguration operations, including resource elastic scaling, task migration, and topology adjustments, supporting hot-swappable incremental or decremental resource configuration.

[0032] The resource scheduler is responsible for mapping simulation tasks to suitable computing nodes for execution, employing a multi-dimensional scheduling strategy. First, the scheduler performs an initial screening based on the task's resource requirements (number of CPU cores, memory capacity, storage space, and reflection memory capacity), excluding nodes that do not meet the minimum requirements. Then, it comprehensively evaluates the nodes based on factors such as current load, geographical location, network latency, and historical task completion status, selecting the optimal node to execute the task. Finally, it notifies the dynamic reconfiguration engine and the corresponding computing nodes of the task scheduling results.

[0033] 1.4 Intelligent Resource Scheduling and Optimization Mechanism The intelligent resource scheduling and optimization mechanism is built on a long-term series prediction model and reinforcement learning algorithm. It can intelligently generate resource allocation optimization strategies based on the real-time status and historical operation characteristics of the simulation task, thereby maximizing resource utilization efficiency.

[0034] The resource demand prediction model employs an Attention-LSTM network, which effectively captures long-term dependencies in resource usage sequences. The model input features include four dimensions: historical resource utilization, task feature vectors, time-series features, and environmental parameters. Historical resource utilization features extract time-series data on CPU utilization, memory usage, network bandwidth utilization, and frequency of reflected memory access for each computing node within the last 24 hours. Task feature vectors are obtained by vectorizing attributes such as the type, scale, duration, priority, and resource requirements of the simulation task. Time-series features include time attributes such as timestamps, day of the week, and whether it is a working day. Environmental parameters include cluster status information such as overall cluster load level, number of running jobs, and recent resource release rate. The prediction model outputs the predicted resource demand for each node within the next 15 minutes. The prediction window covers the resource demand for a preset time period, and the prediction accuracy meets the preset precision requirements, with a prediction error not exceeding 8% under typical load scenarios.

[0035] The reinforcement learning decision engine employs a Deep Q-Network (DQN) algorithm to learn the optimal resource allocation strategy through continuous interaction with the environment. The engine's state space is defined as the global state of the current resource pool, including the resource usage of each node, task queue status, recent resource adjustment history, and the output of the prediction model. The action space is defined as the executable resource adjustment operations, including increasing node resource quotas, decreasing node resource quotas, migrating tasks to other nodes, and adjusting task priorities. The reward function comprehensively considers three objectives: system throughput, energy efficiency, and task completion rate. The reward value is calculated as: system throughput weight multiplied by throughput gain minus energy efficiency weight multiplied by energy efficiency increment, plus task completion rate weight multiplied by completion rate improvement. The decision engine uses an experience replay mechanism and target network technology to improve learning stability and convergence speed, updating the policy every 10 seconds.

[0036] 1.5 Unified Management Framework for Heterogeneous Simulation Resources The heterogeneous simulation resource unified management framework is designed with cross-architecture resource abstraction interfaces and unified scheduling protocols, supporting the access of computing resources of different types and architectures to the resource pool, and realizing transparent management and collaborative scheduling of heterogeneous resources.

[0037] The cross-architecture resource abstraction interface uses the Unified Resource Description Language (URDL) to define the attributes and capabilities of resources. URDL is built on the JSON Schema specification and supports standardized descriptions of attributes of computing resources, such as processor architecture, instruction set characteristics, memory organization, storage hierarchy, network interconnection methods, and accelerator capabilities. Through this unified resource description interface, computing resources with different architectures can be expressed using the same data model, shielding them from the differences in underlying hardware architectures.

[0038] The unified scheduling protocol is compatible with various interconnection methods and communication mechanisms, supporting hybrid access via reflective memory networks, Ethernet, InfiniBand, and dedicated real-time buses. The protocol defines standard operation procedures for resource discovery, resource registration, resource querying, resource reservation, resource release, and resource monitoring. Participating nodes interact through standardized protocol messages. In this embodiment, the scheduling protocol is implemented based on the gRPC framework, using Protocol Buffers as the interface definition language, and supports both synchronous and asynchronous calling modes.

[0039] The heterogeneous resource scheduler internally maintains a resource capability matrix, recording the types of operations supported, access characteristics, and performance metrics for each resource type. When selecting an execution node, the scheduler matches the most suitable resource type based on the specific needs of the task. For example, tasks requiring high-precision floating-point operations are preferentially assigned to nodes equipped with GPU accelerators, while tasks requiring large memory capacity are preferentially assigned to nodes with ample memory resources.

[0040] 1.6 Multi-level fault tolerance and self-healing mechanism The multi-level fault tolerance and self-healing mechanism adopts checkpoint preservation and state recovery technology, combined with primary / standby switching and load transfer strategies, to build a multi-level fault tolerance protection system.

[0041] Node-level fault tolerance employs real-time mirroring technology, establishing a real-time data synchronization channel between the primary and backup nodes. The primary node's operational status, including memory data, register status, and execution context, is replicated to the backup node in real time via a high-speed network. When the primary node experiences hardware failure or software anomalies, the backup node can take over the primary node's role within milliseconds, continuing interrupted tasks and ensuring business continuity. Real-time mirroring technology uses an incremental synchronization strategy, transmitting only changed data, significantly reducing network bandwidth consumption.

[0042] Task-level fault tolerance employs checkpoint recovery technology, periodically saving the execution state of the simulation task to a reliable storage medium. The checkpoint saving interval is configurable, typically every 30 seconds. Checkpoint data includes task computation progress, memory snapshots, file handle status, and communication buffer contents. When a failure occurs during task execution, the system automatically resumes task execution from the most recently saved checkpoint, avoiding recalculation from scratch and significantly reducing fault recovery time.

[0043] System-level fault tolerance is achieved through a load transfer strategy. When a node is detected to be overloaded or about to fail, the dynamic refactoring engine automatically migrates tasks running on that node to other healthy nodes for continued execution. Load transfer employs hot migration technology, ensuring tasks remain running during the migration process without user awareness. System availability reaches a preset high availability level; in this embodiment, the designed availability is 99.99%, meaning unplanned downtime per year will not exceed 52 minutes.

[0044] II. Workflow Deduction Under the above system architecture, the software-defined reflection memory simulation resource pool dynamic reconstruction method of the present invention works in concert according to the following process to realize the dynamic management and optimized scheduling of simulation resources.

[0045] 2.1 Step (1): Virtualization Abstraction and Resource Initialization Process Before submitting the simulation task, it is necessary to first perform deep virtualization abstraction of the physical reflection memory hardware resources and establish a resource topology model and state awareness mechanism.

[0046] After the system powers on, the device discovery module in the hardware abstraction layer performs a PCIe bus scan to identify all connected reflective memory cards. During the scan, the device discovery module reads the PCIe configuration space of each reflective memory card to obtain hardware information such as vendor ID, device ID, base address register, and interrupt vectors. For the identified reflective memory hardware, the driver adaptation module loads the corresponding device driver to complete the hardware initialization configuration. After initialization, the hardware abstraction layer creates a virtual resource object for each reflective memory card, recording its hardware specifications, communication port, and performance parameters.

[0047] The resource mapping module divides the physical memory address space into multiple virtual memory regions according to a preset mapping strategy. In this embodiment, a fixed-size partitioning method is used, dividing the 512MB physical memory into 128 4MB virtual memory regions. Each virtual memory region is assigned a unique identifier (VMID) and has attributes such as access permissions, priority, and bandwidth quota set. The virtual memory region partitioning information is recorded in the resource status database for subsequent resource allocation operations.

[0048] The interface service layer starts the RESTful API service and gRPC service, and begins listening for resource requests from the upper-layer application. During service startup, the interface service layer loads a list of currently available virtual resource units from the resource state database and publishes it to the service registry for the resource scheduler to query.

[0049] 2.2 Step (2): Distributed resource pool construction and node management process The construction process of a distributed simulation resource pool includes four stages: node discovery, registration, state synchronization, and resource integration.

[0050] When a new node joins the resource pool, it first sends a node join request to the resource pool manager via the management network. The request message contains three categories of information: the node's hardware configuration information (CPU model, memory capacity, storage capacity, number of reflective memory cards), network configuration information (IP address, MAC address, VLAN membership), and software environment information (operating system version, runtime library version). Upon receiving the join request, the resource pool manager performs an admission check on the node to verify whether it meets the resource pool's joining conditions, including minimum hardware requirements, software version compatibility, and security policy compliance. After the admission check is passed, the resource pool manager assigns a unique Node Identifier (NID) to the new node and adds it to the member list.

[0051] After node registration is complete, the distributed coordination service begins establishing a state synchronization channel with the new node. The coordination service synchronizes member views and configuration information across all nodes using the Raft protocol, ensuring that each node is aware of changes in resource pool members. In this embodiment, the Raft protocol's member change operation is used, adding the new node as a non-voting member. After log replication is complete, it is then promoted to a voting member, completing the formal joining process.

[0052] The dynamic reconfiguration engine deploys a resource agent on each compute node, responsible for collecting real-time status data of the node. The resource agent periodically reports node status to the resource pool manager, including metrics such as CPU load, memory utilization, disk I / O throughput, network bandwidth usage, reflected memory access latency, and task queue length. The resource pool manager aggregates the status information of all nodes to build a global resource view, reflecting the real-time operating status of the resource pool.

[0053] 2.3 Step (3): Runtime Dynamic Resource Restructuring Process Runtime dynamic resource reconfiguration is one of the core functions of this invention, which enables the elastic scaling and optimized configuration of simulation resources through a dynamic reconfiguration engine.

[0054] The dynamic reconfiguration engine's status monitoring module continuously receives status data reported by resource agents on each node and stores it in a time-series database. Monitoring data retains the most recent 7 days of historical records, supporting trend analysis and anomaly detection. The decision analysis module runs periodically, with a default cycle of 30 seconds, executing the following analysis logic: First, it checks whether the resource utilization of each node exceeds a preset threshold. If CPU utilization exceeds 80% or memory utilization exceeds 85%, a scaling decision is triggered. Second, it checks whether task response latency exceeds a preset threshold. If the average task response time exceeds 500 milliseconds, a performance optimization decision is triggered. Third, it checks whether the load change rate exceeds a preset threshold. If the load change exceeds 30% in the past minute, a load balancing decision is triggered.

[0055] When the decision analysis module determines that resource refactoring needs to be triggered, it generates a refactoring task and submits it to the execution scheduling module. The execution scheduling module calls the corresponding refactoring operation interface based on the specific type of the refactoring task. For resource elastic scaling operations, the execution scheduling module sends resource quota adjustment instructions to the target node, adjusting the allocation of CPU cores, memory allocation, and reflective memory capacity. For task migration operations, the execution scheduling module first reserves sufficient resources on the target node, then initiates the task migration protocol to migrate the task from the source node to the target node, and releases the resources on the source node after the migration is complete. For topology adjustment operations, the execution scheduling module sends topology change instructions to the reflective memory network, adjusting the data synchronization relationships between nodes.

[0056] During the refactoring process, the execution scheduling module monitors the operation progress and task status in real time. For time-consuming refactoring operations, such as large-scale task migration, the execution scheduling module will execute them in batches to avoid instantaneous impact on the system. After the refactoring is completed, the execution scheduling module records the refactoring results in the operation log and reports to the resource pool manager. The resource refactoring engine supports refactoring response times at preset time levels. In this embodiment, the response time for small-scale refactoring (resource adjustment amount less than 20%) does not exceed 10 seconds, and the response time for large-scale refactoring does not exceed 60 seconds. The task interruption time during the refactoring process is less than the preset time threshold. When using hot migration technology, the task interruption time can be less than 100 milliseconds.

[0057] 2.4 Step (4): Intelligent Resource Scheduling and Optimization Process The intelligent resource scheduling and optimization mechanism uses machine learning algorithms to achieve accurate prediction of resource demand and dynamic optimization decision-making.

[0058] The resource demand prediction model employs an attention-based Long Short-Term Memory (LSTM) network for both training and inference. During training, the model uses historically accumulated resource usage data as training samples and learns the mapping relationship between input features and resource demand through backpropagation. The introduction of the attention mechanism enables the model to adaptively focus on key time points in the input sequence, improving its predictive ability for sudden load changes. During inference, the prediction model runs every minute, reading historical resource usage data from the past 24 hours and combining it with current task features and prediction model parameters to output a predicted resource demand value for the next 15 minutes. The prediction results are presented as a probability distribution, including the expected value and confidence interval of the resource demand, providing uncertainty information for subsequent optimization decisions.

[0059] The reinforcement learning decision engine makes resource optimization decisions based on the output of the prediction model and the current system state. The decision engine's workflow includes four steps: state evaluation, action selection, action execution, and reward calculation. In the state evaluation step, the decision engine collects global state information of the current resource pool, including the resource usage of each node, the task queue status, and the output of the prediction model, constructing a current state vector. In the action selection step, the decision engine uses a trained Q-network to calculate the Q-value of each available action in the current state, selecting the action with the largest Q-value as the execution strategy, and employing an ε-greedy strategy to balance exploration and utilization. In the action execution step, the decision engine decomposes the selected action into specific resource adjustment operations and sends them to the dynamic reconstruction engine for execution. In the reward calculation step, after executing the action, the decision engine observes the changes in the system state, calculates the reward value, and updates the parameters of the Q-network.

[0060] In this embodiment, the optimization objective of the reinforcement learning decision engine is a weighted average of three indicators: system throughput, energy efficiency, and task completion rate. System throughput is defined as the number of simulation tasks successfully completed per unit of time; energy efficiency is defined as the computational workload supported by each unit of energy consumption; and task completion rate is defined as the proportion of tasks completed on time out of the total number of tasks. The decision engine continuously optimizes policy parameters through continuous learning, thereby gradually improving the overall system performance.

[0061] 2.5 Step (5): Unified Management Process for Heterogeneous Resources The heterogeneous simulation resource unified management framework enables transparent management and collaborative scheduling of computing resources with different architectures through standardized resource abstraction and scheduling protocols.

[0062] When different types of computing resources are connected to the resource pool, they first register through a cross-architecture resource abstraction interface. The resource registration process includes two stages: capability detection and description publication. The capability detection module obtains the actual computing power, memory access bandwidth, storage performance, and accelerator characteristics of the resources by executing a series of benchmark tests. The description publication module encodes the detection results according to the URDL specification, generates standardized resource description documents, and publishes them to the resource registry center.

[0063] After receiving a simulation task, the resource scheduler matches it against the task's resource requirements and resource capability matrix. The matching process employs a multi-level filtering strategy: the first level filters nodes that do not support the instruction set based on the task's processor architecture requirements; the second level filters nodes with insufficient memory based on the task's memory capacity requirements; and the third level filters nodes equipped with appropriate accelerators based on the task's acceleration requirements. After multi-level filtering, the scheduler comprehensively evaluates the candidate nodes, considering factors such as the node's current load, task queuing time, resource utilization, and historical task completion rate. The node with the highest score is selected to execute the task.

[0064] Data transmission between heterogeneous resources is coordinated using a unified scheduling protocol. This protocol defines the interface and data format conversion rules for cross-architecture data transmission, ensuring correct data exchange between nodes of different architectures. In this embodiment, data transmission supports the following modes: For direct memory access mode, the protocol defines a shared memory mapping mechanism, allowing processes of different architectures to access the same reflected memory region; for message passing mode, the protocol defines a unified message format, including metadata such as data type, byte order, and field alignment, which the sender and receiver use to parse and convert data.

[0065] 2.6 Step (6): Multi-level fault tolerance and self-healing process Multi-level fault tolerance and self-healing mechanisms implement fault detection, fault recovery and self-healing operations at all levels of the system to ensure the reliable operation of the simulation system.

[0066] The node-level fault-tolerant real-time mirroring function continues to operate while the node is running normally. A mirroring agent running on the primary node captures the primary node's memory write operations in real time and synchronizes the changed data to the standby node via a high-speed network. The synchronization process uses an asynchronous mechanism; the agent returns immediately after completing its local operation, without waiting for remote synchronization to complete, ensuring that the primary node's performance is not affected. The standby node continuously receives and applies the changed data from the primary node, maintaining consistency with the primary node's memory state. The bandwidth usage of real-time mirroring can be adjusted through configuration parameters; under the default configuration, the synchronization bandwidth usage does not exceed 20% of the node's network bandwidth.

[0067] When the primary node fails, node-level fault tolerance enters the fault detection and failover phase. Fault detection employs a multi-path heartbeat mechanism, with the standby node and other adjacent nodes simultaneously monitoring the primary node's liveness. A heartbeat signal is sent once per second; if no heartbeat is received for 5 consecutive seconds, the primary node is considered to have failed. Upon fault confirmation, the standby node immediately takes over the primary node's role, increases its network priority, and begins processing requests from clients. Simultaneously, the dynamic refactoring engine triggers a resource reallocation process, migrating tasks previously handled by the primary node to other healthy nodes.

[0068] The task-level fault-tolerant checkpoint saving function runs periodically. During the execution of the simulation task, the checkpoint manager automatically creates checkpoints at preset intervals (configurable from 10 seconds to 300 seconds). The checkpoint creation process includes five steps: pausing task execution, traversing the task memory space, generating a memory snapshot, saving the communication state, and resuming task execution. To minimize the impact on task performance, checkpoint creation uses copy-on-write technology, copying modified pages only when actual memory writes occur. Checkpoint data is saved to a distributed storage system, employing multi-replica redundant storage to ensure reliability.

[0069] When a failure occurs during task execution, task-level fault tolerance enters the recovery phase. The recovery manager first reads the most recently saved checkpoint data from the distributed storage system, and then rebuilds the task's execution environment on the selected recovery node, including allocating resources, loading memory snapshots, and restoring communication state. After the environment reconstruction is complete, the task continues execution from the location where the checkpoint was saved. Checkpoint recovery technology can reduce fault recovery time from recalculating from scratch to the minute level, significantly reducing the waste of computing resources.

[0070] The system-level fault-tolerant load balancing strategy is triggered when abnormal node load or a decline in node health is detected. The dynamic refactoring engine continuously monitors the health score of each node, with scoring factors including resource utilization trends, error rate growth rates, and response time changes. When a node's health score falls below a preset threshold, the refactoring engine automatically initiates a load balancing process, migrating some or all tasks on that node to other healthy nodes. Task migration employs hot migration technology, keeping tasks running during the migration process and achieving a seamless switch for the user through gradual transfer of memory pages.

[0071] Example 2 Based on Example 1, this example further optimizes the system's visual monitoring management and resource quota billing mechanism, making it suitable for providing simulation resource services in multi-tenant scenarios.

[0072] The visualization monitoring and management module is implemented using a web-based management console, providing real-time display of the resource pool topology, node status, resource utilization, and task execution status. The front-end interface of the management console is built using the Vue.js framework and establishes a long-lived connection with the back-end service via the WebSocket protocol to receive real-time status updates. The interface design uses a topology network diagram to display the overall structure of the resource pool, with nodes presented as icons and different colors representing different health states. Resource utilization is displayed in the form of a heatmap, with the horizontal axis representing time and the vertical axis representing resource type, intuitively reflecting the historical trend and current distribution of resource usage. Task execution status is displayed in the form of a Gantt chart, showing the start time, end time, and execution node of each task.

[0073] The resource quota management and billing mechanism supports dynamic quota allocation based on simulation task priority and resource usage. System administrators can set resource quota limits for different tenants, including CPU core hour quotas, memory hourly quotas, and storage capacity quotas. When a task is submitted, the system makes an admission judgment based on the task's priority and the tenant's remaining quota. If the quota is insufficient, the task is rejected or added to a waiting queue. Resource usage is metered to the second, and the metering data is stored in a time-series database, supporting hourly, daily, and monthly summary statistics. The billing module calculates fees based on resource usage and unit price, supporting both prepaid and postpaid billing modes.

[0074] The workflow of this embodiment adds the following steps to the workflow of Embodiment 1: When a tenant submits a simulation task, the system first verifies the tenant's identity and quota balance; during task execution, the resource metering module records resource usage in real time; after the task is completed, the billing module generates a bill and notifies the tenant. The visualization monitoring module continuously displays the resource usage and cost consumption of each tenant, supporting administrators in adjusting quotas and auditing costs.

[0075] The above description is only a preferred embodiment of the present invention, but the scope of protection of the present invention is not limited thereto. Any equivalent substitutions or modifications made by those skilled in the art within the scope of the technology disclosed in the present invention, based on the technical solution and inventive concept of the present invention, should be covered within the scope of protection of the present invention.

Claims

1. A method for dynamically reconstructing a software-defined reflection memory simulation resource pool, characterized in that, Includes the following steps: Step (1) Construct a software-defined reflective memory simulation resource virtualization abstraction layer: Deeply virtualize and abstract physical reflective memory hardware resources, uniformly map computing resources, storage resources and network resources into software-defined virtualized resource objects, establish a resource topology model and state awareness mechanism, and realize transparent upper-layer calls to hardware resources; Step (2) Establish a distributed simulation resource pool management system: Based on the consistent hashing algorithm and distributed coordination service, construct a simulation resource pool with elastic scalability. Deploy a dynamic reconfiguration engine and resource scheduler in the resource pool to support automatic discovery, registration and exit of nodes, and realize centralized management and distributed collaboration of simulation resources. Step (3) Implement runtime dynamic resource reconfiguration: The dynamic reconfiguration engine monitors the load status and resource usage of the simulation task in real time. Based on the preset reconfiguration strategy and real-time analysis results, it automatically performs resource migration, load balancing and capacity adjustment. It supports hot-swappable incremental or decremental resource configuration to ensure the continuous execution of the simulation task. Step (4) Deploy intelligent resource scheduling and optimization mechanism: Based on long-term series prediction model and reinforcement learning algorithm, construct resource demand prediction model and dynamic optimization decision engine, and intelligently generate resource allocation optimization strategy according to the real-time status and historical operation characteristics of simulation task to maximize resource utilization efficiency; Step (5) Construct a unified management framework for heterogeneous simulation resources: Design cross-architecture resource abstraction interfaces and unified scheduling protocols to support the access of computing resources of different types and architectures to the resource pool, realize transparent management and collaborative scheduling of heterogeneous resources, and break down resource architecture barriers; Step (6) Implement a multi-level fault tolerance and self-healing mechanism: adopt checkpoint saving and state recovery technology, combined with master-slave switching and load transfer strategies, to build a multi-level fault tolerance protection system. When a node fails, the self-healing process is automatically triggered to ensure the reliable operation of the simulation system.

2. A software-defined reflection memory simulation resource pool dynamic reconstruction system, characterized in that, include: The virtualization abstraction module is used to perform deep virtualization abstraction of physical reflection memory hardware resources, and to uniformly map computing resources, storage resources and network resources into software-definable virtual resource objects, and establish resource topology models and state awareness mechanisms. The distributed resource pool management module is built on the consistent hashing algorithm and distributed coordination service. It has elastic scaling capabilities, is deployed with a dynamic refactoring engine and resource scheduler, and supports automatic discovery, registration and exit of nodes. The dynamic reconfiguration module is used to monitor the load status and resource usage of simulation tasks in real time, and automatically perform resource migration, load balancing and capacity adjustment according to the preset reconfiguration strategy. The intelligent scheduling module, built on a long-term series prediction model and reinforcement learning algorithm, is used to generate resource allocation optimization strategies. The heterogeneous resource management module is designed with cross-architecture resource abstraction interfaces and a unified scheduling protocol to support access to computing resources of different architectures. The fault-tolerant and self-healing module employs checkpoint saving and state recovery technologies, combined with primary / backup switching and load transfer strategies to achieve multi-level fault-tolerant protection.

3. The method according to claim 1, characterized in that, In step (1), the virtualization abstraction layer adopts a layered architecture design, including a hardware abstraction layer, a resource management layer, and an interface service layer. The hardware abstraction layer is responsible for encapsulating the reflection memory hardware devices from different vendors into standardized virtual resource units. The resource management layer realizes the allocation, recycling, and scheduling of resources. The interface service layer provides a standardized northbound call interface.

4. The system according to claim 2, characterized in that, The virtualization abstraction module adopts a layered architecture design, including a hardware abstraction layer, a resource management layer, and an interface service layer. The hardware abstraction layer is responsible for encapsulating reflection memory hardware devices from different vendors into standardized virtual resource units. The resource management layer implements resource allocation, reclamation, and scheduling. The interface service layer provides standardized northbound call interfaces.

5. The method according to claim 1, characterized in that, In step (2), the simulation resource pool adopts a master-slave architecture design. The resource pool manager, as the master node, is responsible for maintaining the global resource view and scheduling decisions. The distributed coordination service adopts a consistency module based on the Raft protocol to ensure consistent synchronization of resource status information among all nodes.

6. The system according to claim 2, characterized in that, The distributed resource pool management module adopts a master-slave architecture design. The resource pool manager, as the master node, is responsible for maintaining the global resource view and scheduling decisions. The distributed coordination service adopts a consistency module based on the Raft protocol.

7. The method according to claim 1, characterized in that, In step (3), the dynamic refactoring engine adopts an event-driven triggering mechanism. The refactoring triggering conditions include resource utilization threshold, task response latency threshold and load change rate threshold. The refactoring operations include resource elastic scaling, task migration and topology adjustment.

8. The system according to claim 2, characterized in that, The dynamic refactoring module adopts an event-driven triggering mechanism. The refactoring triggering conditions include resource utilization threshold, task response latency threshold, and load change rate threshold. The refactoring operations include resource elastic scaling, task migration, and topology adjustment.

9. The method according to claim 1, characterized in that, It also includes a visualization monitoring and management module for the simulation resource pool, which displays the resource pool topology, node status, resource utilization, and task execution in real time, and supports remote management and configuration operations based on the web.

10. The system according to claim 2, characterized in that, It also includes a visualization monitoring and management module, which displays the resource pool topology, node status, resource utilization, and task execution in real time, and supports web-based remote management and configuration operations.

Images