A distributed rendering task scheduling method based on dynamic load balancing

Abstract

The application provides a distributed rendering task scheduling method based on dynamic load balancing, and relates to the technical field of virtual reality simulation, and comprises the following steps: analyzing and preprocessing input physical simulation data through a multi-source model, and converting the format of the processed data into a manageable virtual set data format; loading texture data on demand to a video memory through a virtual mapping mode; performing dynamic memory loading and coloring based on the virtual set, and completing the generation of LOD; performing dynamic task fragmentation and scheduling on the virtual set rendering task and the heterogeneous multi-source rendering task, and performing real-time monitoring on the GPU / CPU / memory load of the heterogeneous resources, so as to perform task scheduling according to the monitoring result; and in a distributed cluster mode, dividing a high-resolution rendering task into multiple low-resolution rendering tasks for rendering on different nodes. The application provides high-fidelity, high-response and high-reliability three-dimensional visual simulation capabilities for high-complexity scenes such as hybrid power systems.

Description

Technical Field

[0001] The present invention relates to the technical field of virtual reality simulation, and in particular to a distributed rendering task scheduling method based on dynamic load balancing. Background Art

[0002] In hybrid electric 3D scene simulation systems, traditional 3D scene simulation visualization technology has the following defects:

[0003] 1. Bottlenecks in heterogeneous fusion loading and rendering of complex large-scale multi-physics models: Due to the complex characteristic variables (electricity, thermal field, mechanical vibration, etc.) of heterogeneous multi-physics data and model scenarios, multiple rendering levels (tens of millions of faces to hundreds of millions of grids), and state fluidity (dynamic playback, response, and frame sequence synchronization of different data frame sequences), traditional model loading and rendering are overly dependent on the specific performance of computer hardware and cannot evenly utilize CPUs, GPUs, memory, and hard drives to handle the heterogeneous fusion loading and rendering of complex large-scale multi-physics models.

[0004] 2. Real-time rendering is not smooth during interaction: Traditional rendering relies on a single GPU / CPU node to process all scene data (such as tens of millions to hundreds of millions of grids and multi-physics field coupling), and the computing power is insufficient to support real-time frame rates. In addition, traditional rendering methods use predefined rules (such as uniform block division) to distribute rendering tasks, which cannot adapt to the dynamic scene changes of heterogeneous multi-physics field data, resulting in scene freezes, delays, and other problems during interaction.

[0005] 3. Stereoscopic rendering doubles the load: Stereoscopic rendering requires generating independent perspective images for the left and right eyes, resulting in a significant increase in computational effort, video memory usage, and data transmission volume. Traditional rendering architectures are prone to problems such as sudden drops in frame rates and increased latency.

[0006] 4. Support for ultra-high resolution displays: Traditional single-node rendering architectures cannot support ultra-high resolutions and cannot meet the 1:1 immersive, high-pixel requirements when displaying visuals. Summary of the Invention

[0007] In view of this, an embodiment of the present application provides a distributed rendering task scheduling method based on dynamic load balancing, which aims to solve the problems of hybrid electric three-dimensional visual simulation system multi-system, multi-physical field coupling complex large model scene simulation model data fusion, interactive real-time rendering jams, stereo rendering load and ultra-high resolution real-time rendering display visualization rendering requirements. By targeting the characteristics of multi-system and multi-physical field coupling of hybrid electric projects, the visual simulation system operation logic and physical architecture are designed, and a three-dimensional visual simulation system is developed to realize the data fusion of the top-level three-dimensional visual model and the underlying system-level real-time simulation model. Through data visualization technology, the visual display of the hybrid electric system and the dynamic virtual demonstration of the hybrid electric system application scenario are demonstrated, thereby improving the visualization design and verification capabilities of the hybrid electric system.

[0008] The present application provides the following technical solution: a distributed rendering task scheduling method based on dynamic load balancing, comprising:

[0009] The input physical simulation data is parsed and preprocessed through a multi-source model to obtain processed data;

[0010] Converting the processed data into a manageable virtual set data format; loading the texture data into the video memory on demand through virtual mapping; performing dynamic memory loading and shading based on the virtual set to complete LOD generation to achieve dynamic load balancing;

[0011] Dynamically partition and schedule virtual set rendering tasks and heterogeneous multi-source rendering tasks, and monitor the GPU / CPU / memory load of heterogeneous resources in real time to schedule tasks based on the monitoring results.

[0012] Through distributed clustering, high-resolution rendering tasks are divided into multiple low-resolution rendering tasks and rendered on different nodes.

[0013] According to one embodiment of the present application, the input physical simulation data is parsed and preprocessed using a multi-source model, including:

[0014] The format of the input physical simulation data is identified by a format identifier, and preprocessing steps including geometric topology analysis, feature extraction, and material merging are performed.

[0015] According to one embodiment of the present application, converting the format of the processed data into a manageable virtual set data format includes:

[0016] The geometric grid of the processed data is segmented into pixelated and colored virtual geometric data, and the data structure of the feature data is remapped to form a manageable virtual set data format; wherein the segmentation of the geometric grid is based on surface curvature or space division.

[0017] According to one embodiment of the present application, the process of dynamic memory loading and shading based on the virtual set includes: predicting the camera position, predicting the viewing frustum, geometric virtual set priority scoring, loading scheduling strategy based on the geometric virtual set priority scoring, and adaptive adjustment mechanism based on dynamically updated prediction time step.

[0018] According to one embodiment of the present application, the dynamic task slicing and scheduling includes task splitting, task allocation and load scheduling; wherein, task splitting and task allocation are performed on virtual set rendering tasks and heterogeneous multi-source rendering tasks based on pixel, object, or pixel and object hybrid strategies.

[0019] According to one embodiment of the present application, the distributed cluster mode includes a master-slave mode, which includes one or more master nodes and several slave nodes. The master node is responsible for managing and scheduling rendering tasks, and the slave node is used to execute the rendering tasks assigned by the master node.

[0020] According to one embodiment of the present application, the distributed cluster method also includes a peer-to-peer mode; in the peer-to-peer mode, each node can create a rendering task and broadcast the created task information to other nodes in the network. Each node is matched to the rendering task to be executed based on the current resource status and priority of the node.

[0021] According to an embodiment of the present application, it also includes: synchronizing the rendering data stream and compressing the intermediate data during the data transmission process; the synchronization includes task allocation synchronization, state synchronization, and data synchronization.

[0022] According to an embodiment of the present application, the method further includes: previewing the rendering results in real time through a visualization terminal, and automatically adjusting the rendering strategy according to the rendering results to form a closed-loop feedback loop.

[0023] Compared with the traditional real-time rendering task scheduling method, the beneficial effects achieved by at least one of the above technical solutions adopted in the embodiments of this specification include at least the following: the embodiment of the present invention dynamically allocates GPU / CPU / edge nodes according to the physical field characteristics (sparse / dense data), and the resource utilization rate is increased to more than 85%; through virtual mapping, it supports cross-format texture and parameter fusion, and the multi-field coupling mapping is much higher than the traditional physical field data source processing real-time efficiency, which is increased by more than 50%; through the characteristics of multi-physical field heterogeneous data, combined with advanced shading technology, distributed rendering technology, LOD technology, rendering culling technology and other multi-technology integration Combined optimization, the mesh simplification rate in long-distance areas is 70%, video memory usage is reduced by 50%, invalid rendering calculations are reduced by 60%, and the recovery time required to reload the entire scene after a node failure is shortened by 80%. The frame rate of complex assemblies in single-node tens of millions of mesh scenes is increased from <10fps to >30fps below ultra-large resolution, achieving smooth operation and interaction at ultra-large resolution. Real-time rendering of heterogeneous multi-physics data can be performed smoothly, systematically solving the bottlenecks of traditional technologies in resource utilization, real-time performance, accuracy and stability, and providing high-fidelity, high-responsiveness and high-reliability 3D scene simulation capabilities for highly complex scenarios such as hybrid electric systems. BRIEF DESCRIPTION OF THE DRAWINGS

[0024] In order to more clearly illustrate the technical solutions of the embodiments of the present application, the following briefly introduces the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0025] Figure 1 This is a flow chart of a distributed rendering task scheduling method based on dynamic load balancing according to an embodiment of the present invention;

[0026] Figure 2 This is a schematic diagram of the data input layer implementation process in an embodiment of the present invention;

[0027] Figure 3 Schematic diagram of the format conversion process in the resource optimization layer in an embodiment of the present invention;

[0028] Figure 4 is a schematic diagram of the virtual texture management process in the resource optimization layer in an embodiment of the present invention;

[0029] Figure 5 Schematic diagram of the LOD generation process in the resource optimization layer in an embodiment of the present invention;

[0030] Figure 6 Schematic diagram of the implementation process of task segmentation and allocation in the scheduling core layer in an embodiment of the present invention;

[0031] Figure 7 Schematic diagram of the implementation process of the distributed cluster in the rendering execution layer in an embodiment of the present invention;

[0032] Figure 8 Schematic diagram of the synchronization process in the transmission control layer in an embodiment of the present invention;

[0033] Figure 9 It is a schematic diagram of the implementation process of the interaction and feedback layer in an embodiment of the present invention. DETAILED DESCRIPTION

[0034] The embodiments of the present application are described in detail below with reference to the accompanying drawings.

[0035] The following describes the embodiments of the present application through specific examples, and those skilled in the art can easily understand other advantages and effects of the present application from the contents disclosed in this specification. Obviously, the described embodiments are only a part of the embodiments of the present application, rather than all the embodiments. The present application can also be implemented or applied through other different specific embodiments, and the details in this specification can also be modified or changed in various ways based on different viewpoints and applications without departing from the spirit of the present application. It should be noted that, in the absence of conflict, the features in the following embodiments and embodiments can be combined with each other. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without making creative work are within the scope of protection of this application.

[0036] An embodiment of the present invention provides a distributed rendering task scheduling method based on dynamic load balancing, comprising:

[0037] The input physical simulation data is parsed and preprocessed through a multi-source model to obtain processed data;

[0038] Converting the processed data into a manageable virtual set data format; loading the texture data into the video memory on demand through virtual mapping; performing dynamic memory loading and shading based on the virtual set to complete LOD generation to achieve dynamic load balancing;

[0039] Dynamically partition and schedule virtual set rendering tasks and heterogeneous multi-source rendering tasks, and monitor the GPU / CPU / memory load of heterogeneous resources in real time to schedule tasks based on the monitoring results.

[0040] Through distributed clustering, high-resolution rendering tasks are divided into multiple low-resolution rendering tasks and rendered on different nodes.

[0041] An embodiment of the present invention provides a distributed rendering task scheduling method for a hybrid electric three-dimensional visual simulation system. Based on a dynamic load balancing algorithm, it realizes the data fusion of the top-level three-dimensional visual model and the underlying system-level real-time simulation model, and dynamically demonstrates the application scenario of the hybrid electric system. Distributed rendering technology dynamically allocates GPU / CPU cluster resources to address the uneven computing load of heterogeneous multi-physics (electrical, thermal, and mechanical) coupled scenarios. Virtual mapping technology is combined with unified management of multi-system model texture resources to achieve efficient cross-format data fusion. Multi-detail Level of Detail (LOD) technology is used to hierarchically simplify mesh complexity in distant or non-focus areas, reducing video memory and bandwidth pressure and alleviating interaction lag. Advanced shading model technologies (such as PBR) accurately simulate the physical properties of multiple materials, including metals and insulators, enhancing the realism of virtual-to-real mapping in hybrid systems. View frustum and occlusion culling technologies dynamically filter invisible objects, reducing ineffective rendering calculations by over 50%. To address the doubling of stereo rendering load, a spatial slicing strategy is used to split left and right eye view tasks onto edge nodes for parallel processing. Combined with cloud-edge collaborative streaming and elastic resource pooling, this supports smooth rendering at frame rates exceeding 30 fps at 8K ultra-high-definition resolution. Finally, through low-latency data injection and dynamic priority scheduling, millisecond-level synchronization (<20ms) between multi-physics simulation data and scene models is achieved, ensuring real-time interaction and high-fidelity visualization verification throughout the entire lifecycle of scenes with tens of millions of meshes.

[0042] like Figure 1As shown, in some embodiments of the present invention, a distributed rendering task scheduling solution based on dynamic load balancing, through a layered modular architecture and dynamic feedback control, closely integrates distributed rendering task scheduling, multi-physics field data fusion, and real-time interactive optimization, forming a complete closed loop from data input to visualization terminal, providing a scalable and highly available implementation path for visual simulation of highly complex scenarios such as hybrid electric systems. The main functional designs of the embodiments of the present invention are as follows:

[0043] 1. Data input layer

[0044] Multi-source model analysis: supports multi-source models such as CAD / CAE models.

[0045] 2. Resource optimization layer

[0046] Format conversion (cross-platform compatibility), virtual map management (texture resource pool), LOD generation (dynamic level of detail).

[0047] 3. Scheduling core layer

[0048] Dynamic task slicing and scheduling: task segmentation, allocation, and load scheduling;

[0049] Heterogeneous resource monitoring and scheduling: Real-time monitoring of GPU / CPU / memory loads and allocation of tasks to the optimal node.

[0050] 4. Rendering execution layer

[0051] Distributed cluster: supports distributed cluster rendering, achieving stereoscopic, high-resolution, interactive real-time rendering.

[0052] 5. Transport Control Layer

[0053] Synchronize rendering data streams, compress and transmit intermediate results, and ensure consistency of multi-node collaboration.

[0054] 6. Interaction and feedback layer

[0055] Visual terminal: real-time preview / user intervention;

[0056] Feedback loop: collect rendering time / error rate and dynamically adjust sharding strategy.

[0057] In the specific implementation, the implementation process of each step is as follows:

[0058] 1. Data input layer implementation

[0059] The data input layer is the implementation of the parsing process of the multi-source model, such as Figure 2 As shown in the figure, the implementation steps are as follows: physical simulation data is input into multi-source models such as CAD / CAE models, and then the format identifier is used to perform geometric analysis, feature extraction, material merging, and preprocessing.

[0060] Implementation of format identifiers: Create classifiers based on the format library and API of the multi-source model to identify different file formats or data structures. For specific application scenarios, use specialized rule sets to parse known data formats.

[0061] Implementation of geometric topology parser: This embodiment uses a triangulation method to parse the surface representing a three-dimensional object and constructs a graphic model to describe the connection relationship between objects.

[0062] Feature extractor implementation: This embodiment extracts key information describing the shape, structure or semantics of an object from the geometric structure, topological relationship and attribute information in the three-dimensional data.

[0063] Implementation of the material merger: Merge the materials of multiple geometries (such as mesh subcomponents) with the same or similar material properties into one material group and render them using a unified material.

[0064] 2. Implementation of the resource optimization layer

[0065] The resource optimization layer is one of the key steps to optimize and improve rendering performance after data input. This embodiment performs data format conversion, virtual texture management, and LOD generation according to the rendering process and important optimization steps.

[0066] Format conversion: After parsing and inputting multi-source data, the data is converted into a data structure that can be used by this platform. At the same time, large model data is further converted and processed. In particular, for models with heavy rendering loads, traditional triangle meshes are processed into manageable virtual sets to achieve dynamic balancing. Figure 3 As shown, the format conversion newly added in this embodiment is different from the traditional geometric mesh conversion. After the conversion, the geometric data needs to be converted into a manageable virtual geometry, and the data structure of the feature data needs to be remapped to form a manageable virtual set data format.

[0067] Key methods of virtual geometry: Split the geometric mesh into pixelated virtual geometry to generate dynamic geometry support for LOD. Geometry segmentation is mainly performed based on surface curvature or spatial partitioning (octree) to ensure topological continuity within the virtual geometry.

[0068] Virtual Texture Management: Virtual texture management is a technology for efficiently managing large amounts of texture data. It works by loading texture data into video memory on demand, rather than loading all textures at once, enabling dynamic loading of texture maps. Virtual texture management utilizes tiled textures, dynamic loading, and intelligent caching to efficiently manage ultra-high-definition textures. In 4K rendering scenarios, texture memory usage is reduced by over 85%, completely eliminating rendering lag caused by texture loading.

[0069] Typical process of virtual mapping implementation: Figure 4 As shown in the figure, consider a large texture map divided into multiple tiles, each 256x256 pixels in size. During loading, the system determines which tiles to load based on the coordinate range within the current viewport. If the current viewport is about to slide to the next tile, that tile is loaded in advance. Simultaneously, a background thread continuously loads data for tiles that are about to enter the viewport, ensuring that rendering is not delayed by waiting for loading.

[0070] LOD generation: LOD is one of the important units in rendering load. Traditional LOD generation often requires manual processing and cannot be adaptive. In addition to the traditional LOD adaptation of some regular data, this embodiment also uses virtual set format conversion and dynamic LOD for large model data, which can achieve dynamic load balancing. Figure 5 As shown, the LOD generation solution of this embodiment is implemented by dynamically loading and shading based on virtual sets.

[0071] Implementation method and process: The dynamic memory loading and shading of this embodiment is implemented by predicting the camera position, viewing frustum, virtual set priority scoring, loading scheduling strategy, adaptive adjustment mechanism to output shading rendering and other stages.

[0072] 1) Predicting camera position

[0073] Position prediction using physical motion models

[0074] Uniform speed model (short-term forecast):

[0075]

[0076] Uniform acceleration model (more accurate):

[0077]

[0078] in, is the current camera position (3D vector), is the current camera speed (3D vector), is the prediction time step (e.g. 0.5 seconds), is the current camera acceleration (3D vector), is the predicted camera position, Indicates prediction.

[0079] 2) Predicting the visual cone

[0080] The camera's view frustum consists of six clipping planes (left, right, top, bottom, near, and far). When predicting the future view frustum, in addition to considering position changes, we also need to consider the camera's rotation changes (i.e., the direction of view).

[0081] Assume that the current camera's viewing direction is d(t) and its angular velocity is ω(t). To predict the time step, the future direction can be expressed as:

[0082]

[0083] Among them, rotate() means rotating the direction according to the angular velocity (which can be calculated by quaternion interpolation or Euler angle), and the other parameters are the same as those in the above predicted camera position; Represents the predicted camera viewing direction.

[0084] 3) Geometric virtual set priority scoring

[0085] The geometry virtual set priority score determines which geometries should be loaded first, using a distance-visibility score function, which can be formalized as:

[0086]

[0087] : Predict the distance between the camera and the center of the i-th geometric block;

[0088] in, represents the priority score of the geometric virtual set, i represents the geometric block index, L i Indicates the center point of the i-th geometric block, C predicted represents the predicted camera position; : The probability of visibility of the i-indexed geometry block in the future viewing frustum (0 means completely invisible, 1 means completely visible); α and β are weight coefficients that control the relative importance of distance and visibility.

[0089] 4) Loading scheduling strategy

[0090] Based on the priority score of the geometric virtual set, the system maintains a priority queue. Sorting, loading the most prioritized data blocks in order. In addition, the following factors are implemented in the same way as regular rendering.

[0091] a. Network / disk bandwidth limitations; b. GPU memory capacity; c. Number of data blocks currently being loaded; d. Data compression ratio and decompression time.

[0092] 5) Adaptive adjustment mechanism

[0093] Test loading is not a static process, but a dynamic adjustment process, which usually includes:

[0094] Dynamic update Δt: adjust the prediction time step according to frame rate fluctuations;

[0095] Actual visibility feedback: Compare the difference between predicted and actual visibility in each frame and correct the prediction model;

[0096] Record reference: record historical behavior and optimize predictions.

[0097] 3. Scheduling core layer

[0098] Dynamic Task Slicing and Scheduling: Task segmentation and load scheduling. This embodiment of the present invention is compatible with traditional rendering tasks, newly added virtual set rendering tasks, and heterogeneous multi-source rendering tasks to adapt to relevant applications. In the task allocation process, in addition to traditional object-based task allocation, this embodiment of the present invention also adopts a pixel-based and hybrid strategy to allocate tasks to virtual sets and heterogeneous sources.

[0099] Implementation of task splitting and allocation, such as Figure 6 shown.

[0100] Task division method: Assume there is a large rendering task T, which needs to be divided into Small tasks , where i=1,2,…,n. Each task Need to be executed on the slave node.

[0101] Task segmentation model:

[0102] here Indicates the subtasks, From a computational perspective, it is an independent subtask work unit (completion time, scene resource amount (such as number of scenes, number of frames, number of images...)), etc.), and T is the sum of the subtask work units of a large rendering task.

[0103] Task allocation implementation principle:

[0104] To achieve load balancing, a task allocation strategy based on the current load level of the slave nodes can be adopted. For example, the node with the lowest current load is selected to accept the new task.

[0105] Performance metrics: To evaluate the performance of a distributed rendering system, some metrics can be defined, such as task completion time. and system throughput .

[0106] Completion time:

[0107]

[0108] Where i represents the task index, represents the completion time of the i-th task, represents the time of the i-th subtask, Indicates the start execution time of the i-th task, Indicates the execution cycle time of the i-th task.

[0109] Throughput:

[0110]

[0111] here It is the completion time of the latest task among all tasks, max is the latest task, Indicates the amount of tasks processed by the system per unit time. For rendering tasks, the amount of resources (image, scene, lighting, pixels...) in the scene rendering task. The parameters are the same as the task segmentation model above.

[0112] Minimize the maximum completion time:

[0113]

[0114] in, Represents the minimize operation, It means taking the maximum value for all i. represents the completion time of the i-th task, Represents the optimization variable or decision variable, that is, the task allocation plan.

[0115] The goal here is to minimize the completion time of the latest completed task, thereby achieving efficient operation of the entire system.

[0116] Task allocation implementation process

[0117] In distributed rendering, the way tasks are allocated directly affects rendering efficiency and load balancing. The task allocation strategies in the embodiments of the present invention include pixel-based, object-based, and hybrid strategies.

[0118] 1. Pixel-based task allocation

[0119] Pixel-based task allocation refers to dividing the image into multiple pixel blocks and then assigning these pixel blocks to different computing nodes for rendering. Pixel-based rendering is applicable to virtual set rendering.

[0120] Implementation steps:

[0121] (1) Image segmentation: First, determine the image resolution and segment it into multiple fixed-size rectangular regions (pixel blocks). For example, a 1024×768 image can be divided into 32×24 grids, each of which is an independent rendering task.

[0122] (2) Task allocation: Each pixel block is treated as an independent task and distributed to different rendering nodes. Polling or other load balancing algorithms can be used to allocate tasks.

[0123] (3) Task execution and result collection: Each node renders the pixel block assigned to it and returns the result to the master node or stores it in a shared location.

[0124] (4) Result integration: The master node collects all pixel block results and combines them into a complete image.

[0125] Algorithm: Assume that the resolution of the image (width W height H size) is , the size of each pixel block is , then the image can be segmented into Pixel blocks, blocks represents the pixel block index, Indicates the number of pixel blocks after segmentation.

[0126] ,in Indicates rounding up.

[0127] 2. Object-based task allocation

[0128] Object-based task allocation refers to using geometric objects or objects in the scene as the unit of rendering tasks, rather than image pixels. It is applicable to traditional object objects.

[0129] Implementation steps:

[0130] (1) Object segmentation: Divide the geometric objects in the scene according to logical or physical boundaries to form multiple independent rendering objects.

[0131] (2) Task allocation: Distribute each object as an independent task to different rendering nodes.

[0132] (3) Task execution and result collection: Each node renders the object assigned to it and returns the result to the master node or stores it in a shared location.

[0133] (4) Result integration: The master node collects the rendering results of all objects and combines them into a complete scene image.

[0134] Algorithm: If there are n objects in the scene, then there are n rendering tasks.

[0135] 3. Task Allocation with Hybrid Strategies

[0136] The hybrid strategy combines the advantages of the first two strategies, taking into account both the pixel distribution of the image and the segmentation of objects in the scene. The hybrid strategy is suitable for rendering tasks with heterogeneous data sources.

[0137] Implementation steps:

[0138] (1) Segmentation and task definition: First, the objects in the scene can be segmented, and then the pixel blocks required for rendering each object can be further divided.

[0139] (2) Task distribution: Distribute these mixed tasks to different rendering nodes.

[0140] (3) Task execution and result collection: Each node renders the task assigned to it and returns the results to the master node or stores them in a shared location.

[0141] (4) Result integration: The master node collects the rendering results of all tasks and combines them into a complete image.

[0142] Algorithm method: Assume there are n objects in the scene, and each object is divided into m i pixel blocks, there are tasks.

[0143] Load Scheduling

[0144] Dynamic load scheduling in the embodiment of the present invention refers to real-time adjustment based on the actual load of each node during task execution. This method can better adapt to changes in system load, thereby improving system responsiveness and utilization.

[0145] Implementation method:

[0146] (1) Load monitoring: Regularly collect the load information of each node.

[0147] (2) Load evaluation: Evaluate the current load of the node based on the collected information.

[0148] (3) Task migration: When a node is found to be overloaded, some tasks on that node can be migrated to a node with a lower load.

[0149] (4) Load balancing: Achieve load balancing by dynamically adjusting task allocation.

[0150] Algorithm formula:

[0151] Assume that each node With load value , and the desired average load is , avg means average.

[0152] Load calculation: , where i=1,2,3…, and N represents the total number of nodes.

[0153] Load Regulation: If , you need to move the task from the node Migrate out; if , you can accept more tasks, is the tolerance threshold, which is used to smooth the decision and avoid unnecessary task migration overhead.

[0154] Scheduling Balance

[0155] Scheduling balance means taking load balance into consideration during the task allocation phase to avoid allocating too many tasks to a node at the beginning, which would lead to uneven load.

[0156] Implementation method:

[0157] (1) Task initialization: Prepare a list of tasks to be assigned. (2) Node initialization: Record the current load status of each node. (3) Task allocation: Select the appropriate node to assign tasks based on the current load status of the node. (4) Load update: Update the node load information after each task is assigned.

[0158] Algorithm formula: Assume that the node The current load is , the total number of tasks is n, the weight of each task is w, then the node The load can be expressed as , where j represents the node assigned to The task, that is It is represented as the weight of the jth task of node i.

[0159] Minimum load selection: ,in The superscript in the middle is the optimal solution, and argmin represents the parameter with the minimum value, that is, finding The index i of the node with the smallest load value.

[0160] Heterogeneous resource monitoring and scheduling: Real-time monitoring of GPU / CPU / memory loads, assigning tasks to the best nodes. This solution uses probe monitoring and a dynamic weight calculation model to achieve heterogeneous resource monitoring and scheduling. The implementation process is as follows:

[0161] (1) Probe monitoring: Use GPU collector (sampling frequency 500ms) for probe monitoring

[0162] (2) Dynamic weight calculation model:

[0163]

[0164] 4. Rendering execution layer

[0165] Distributed cluster: supports distributed cluster rendering, achieving stereoscopic, high-resolution, interactive real-time rendering.

[0166] Stereoscopic rendering, high-resolution rendering, and interactive real-time rendering require a huge rendering load, making larger scenes basically unattainable. The present invention uses a distributed cluster approach to divide high-resolution rendering into multiple smaller resolutions and render them on different machines. At the same time, the stereoscopic binocular image rendering is divided into a complete image that can be spliced ​​together, thereby improving real-time rendering efficiency and achieving real-time interaction and response of the overall image. Figure 7 shown.

[0167] The distributed cluster rendering method of the embodiment of the present invention has two modes: master-slave mode and peer-to-peer mode, which are suitable for different application scenarios.

[0168] 1. Master-slave mode

[0169] In the master-slave model, the system consists of one or more master nodes (Master) and several slave nodes (Slave). The master node is responsible for managing and scheduling rendering tasks, while the slave nodes focus on executing the tasks assigned to them.

[0170] Implementation steps:

[0171] (1) Task division: The master node divides the entire rendering task into smaller parts and assigns a unique identifier to each part.

[0172] (2) Task allocation: The master node distributes tasks to different slave nodes based on the capabilities and current load conditions of the slave nodes.

[0173] (3) Task execution: After receiving the task, the slave node starts to perform the rendering operation and returns the result to the master node.

[0174] (4) Result integration: The master node collects the results returned by all slave nodes and combines them into the final image or animation sequence.

[0175] Master node method: (1) Initialization: Establish connections and initialize all slave nodes. (2) Task division: Decompose the rendering task into multiple subtasks. (3) Task allocation: Assign subtasks based on the load of the slave nodes. (4) Result collection: Wait for all subtasks to complete and collect the results. (5) Result integration: Integrate all collected subtask results into the final rendering result. (6) Load monitoring and redistribution: Continuously monitor the status of the slave nodes and redistribute tasks as needed.

[0176] Slave node methods: (1) Initialization: Connect to the master node and wait for tasks. (2) Task reception: Get tasks from the task queue. (3) Task execution: Execute the assigned tasks. (4) Result transmission: Send the results back to the master node.

[0177] 2. Peer-to-peer mode

[0178] In peer-to-peer mode, every node in the network has equal status and can initiate task requests and execute tasks. This approach allows for greater flexibility and better fault tolerance.

[0179] Implementation steps:

[0180] (1) Task publishing: Any node can create rendering tasks and broadcast the information of these tasks to other nodes in the network.

[0181] (2) Task selection: Each node selects the task it wants to perform based on its own resource status and priority.

[0182] (3) Task execution: Once a task is selected, the node begins to perform the rendering operation and sends the results back to the node that initiated the task.

[0183] (4) Result verification and merging: The task initiating node needs to verify the received results and merge them into the final output.

[0184] Node methods: (1) Task publishing: broadcasting task information. (2) Task selection: selecting executable tasks. (3) Task execution: executing the selected tasks. (4) Result sending: sending the results to the task initiator. (5) Result verification and merging: for the initiator, verifying the results and merging them.

[0185] 5. Transport Control Layer

[0186] The transmission control layer's business is to synchronize rendering data streams, compress and transmit intermediate results, and ensure consistency in multi-node collaboration. The transmission control layer is divided into two parts: synchronization and transmission control. The specific implementation is as follows:

[0187] Synchronous processing involves multiple technologies and methods, including but not limited to task allocation, state synchronization, data synchronization, etc. Figure 8 As shown, the following details the implementation principles and specific methods of synchronization processing in distributed rendering.

[0188] 1. Synchronization of task allocation

[0189] Task allocation is one of the key steps in a distributed rendering system. It is necessary to ensure that the slave nodes can correctly receive tasks and execute them in the predetermined manner.

[0190] Implementation method:

[0191] (1) Task allocation algorithm: The master node uses an algorithm (greedy algorithm, genetic algorithm) to decide how to allocate tasks to each slave node.

[0192] (2) Task allocation protocol: Define a set of task allocation protocols to clarify the task allocation process, message format and response mechanism.

[0193] (3) Task assignment message: The master node sends a task assignment message through the network, which contains the specific content of the task, execution parameters and other information.

[0194] 2. State Synchronization

[0195] State synchronization is to ensure that the master node can timely understand the status of the slave nodes, including but not limited to rendering progress, load conditions, health status, etc.

[0196] Implementation method:

[0197] (1) Periodic reporting: Slave nodes periodically send status reports to the master node. (2) Event-driven: Slave nodes send notifications to the master node when specific events occur (such as task completion or error). (3) Heartbeat detection: The master node periodically sends heartbeat signals to the slave nodes, and the slave nodes respond to the heartbeat signals to indicate their own status.

[0198] 3. Data synchronization

[0199] Data synchronization is to ensure the consistency and integrity of data, especially when transferring data between multiple nodes.

[0200] Implementation method: (1) Version control: Add version numbers to data to ensure data consistency. (2) Data verification: Use checksums (such as CRC, MD5) to verify data integrity. (3) Retry mechanism: Automatically retry when data transmission fails when the network is unstable.

[0201] Transmission control: Transmission refers to the exchange of task data and result data between the master node and the slave nodes. To improve transmission efficiency, various technical means can be used.

[0202] The workflow is as follows: (1) Data preparation: The master node prepares the data to be transmitted, such as scene descriptions, model data, texture maps, etc. (2) Data compression: Compresses the data to reduce the amount of data transmitted. (3) Data encryption: Encrypts sensitive data to ensure data security. (4) Data transmission: Sends data to the slave node via the network. (5) Data reception: The slave node receives the data and performs decompression and decryption. (6) Data verification: Verifies the integrity and correctness of the data.

[0203] Implementation principle: (1) Compression algorithm: Use compression algorithms such as GZIP, LZ4, and Brotli to reduce data volume. (2) Encryption algorithm: Use encryption algorithms such as AES to ensure data transmission security. (3) Reliable transmission: Use the TCP protocol to ensure reliable data transmission, or use UDP in combination with upper-layer protocols to achieve reliable transmission. (4) Data verification: Use methods such as CRC to ensure data integrity.

[0204] 6. Interaction and feedback layer

[0205] The implementation process architecture design of the interaction and feedback layer of the embodiment of the present invention is as follows Figure 9 As shown:

[0206] The interaction and feedback layer primarily involves the visualization terminal providing real-time feedback on user operations, collecting rendering time and error rates, and dynamically adjusting sharding strategies to form a closed feedback loop. This interactive feedback layer runs through the entire rendering process, encompassing the visualization terminal, user operations, parameter adjustment commands, the dispatch center, the rendering cluster, performance monitoring, feedback analysis, and other interactive and feedback processes.

[0207] Visual terminal: Users can preview the rendering results in real time through the visual terminal and make necessary interventions and adjustments.

[0208] User operation: On the visualization terminal, users can perform various operations. The rendering efficiency, such as frame rate and image quality, responds to relevant interactive effects in real time, makes responsive adjustments based on the interactive results, adjusts parameters, selects different rendering modes, etc.

[0209] Parameter adjustment instructions: User operations will be converted into specific parameter adjustment instructions, which will guide the subsequent rendering process.

[0210] Scheduling Center: Parameter adjustment commands are sent to the Scheduling Center, which manages and coordinates the distribution and execution of rendering tasks. It rationally assigns rendering tasks to various nodes in the rendering cluster based on current resource availability and task requirements.

[0211] Rendering cluster: executes specific rendering tasks according to the arrangement of the scheduling center.

[0212] Performance monitoring: During the rendering process, the performance monitoring module continuously collects key indicators such as rendering time and error rate. These data are crucial for evaluating rendering efficiency and quality.

[0213] Feedback Analyzer: The collected performance data is sent to the Feedback Analyzer for analysis. The Feedback Analyzer dynamically adjusts the sharding strategy based on this data to optimize the rendering process and improve rendering efficiency and quality.

[0214] Adaptive strategy: Based on the analysis results of the feedback analyzer, the system automatically adjusts the rendering strategy, such as changing the task sharding method, optimizing resource allocation, etc., to achieve better rendering effects.

[0215] Feedback loop: Through the above process, the system forms a closed-loop feedback mechanism. Starting from user operation, through parameter adjustment, task scheduling, rendering execution, performance monitoring, data analysis, and then strategy adjustment, it ultimately affects user operation and parameter adjustment again, forming a continuous optimization cycle.

[0216] The embodiment of the present invention specifically targets the characteristics of multi-system and multi-physical field coupling in hybrid electric projects, designs the operating logic and physical architecture of the visual simulation system, develops a three-dimensional visual simulation system, realizes the data fusion of the top-level three-dimensional visual model and the underlying system-level real-time simulation model, displays the visual of the hybrid electric system through data visualization technology, adopts data-driven visualization technology, and dynamically demonstrates the application scenarios of the hybrid electric system, thereby improving the visual design and verification capabilities of the hybrid electric system.

[0217] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in the present application should be included in the scope of protection of the present application. Therefore, the scope of protection of the present application should be based on the scope of protection of the claims.

Claims

1. A distributed rendering task scheduling method based on dynamic load balancing, characterized in that: include: The input physical simulation data is parsed and preprocessed through a multi-source model to obtain processed data; Converting the processed data into a manageable virtual set data format; loading the texture data into the video memory as needed by means of virtual mapping; Dynamic memory loading and shading are performed based on the virtual set to complete LOD generation to achieve dynamic load balancing; Dynamically partition and schedule virtual set rendering tasks and heterogeneous multi-source rendering tasks, and monitor the GPU / CPU / memory load of heterogeneous resources in real time to schedule tasks based on the monitoring results. By using a distributed cluster approach, high-resolution rendering tasks are divided into multiple low-resolution rendering tasks and rendered on different nodes; The step of converting the processed data into a manageable virtual set data format includes: Segmenting the processed data's geometric grid into pixelated, shaded virtual geometric data, and remapping the data structure of the feature data to form a manageable virtual set data format; wherein the segmentation of the geometric grid is based on surface curvature or spatial partitioning; The process of dynamic memory loading and shading based on the virtual set includes: predicting camera position, predicting viewing frustum, geometric virtual set priority scoring, loading scheduling strategy based on the geometric virtual set priority scoring, and adaptive adjustment mechanism of prediction time step based on dynamic update.

2. The distributed rendering task scheduling method based on dynamic load balancing according to claim 1 is characterized in that: The input physical simulation data is parsed and preprocessed through multi-source models, including: The format of the input physical simulation data is identified by a format identifier, and preprocessing steps including geometric topology analysis, feature extraction, and material merging are performed.

3. The distributed rendering task scheduling method based on dynamic load balancing according to claim 1 is characterized in that: The dynamic task slicing and scheduling includes task segmentation, task allocation and load scheduling; wherein, task segmentation and task allocation are performed on virtual set rendering tasks and heterogeneous multi-source rendering tasks based on pixel, object, or pixel and object hybrid strategies.

4. The distributed rendering task scheduling method based on dynamic load balancing according to claim 1, characterized in that: The distributed cluster mode includes a master-slave mode, which includes one or more master nodes and several slave nodes. The master node is responsible for managing and scheduling rendering tasks, and the slave nodes are used to execute rendering tasks assigned by the master node.

5. The distributed rendering task scheduling method based on dynamic load balancing according to claim 4 is characterized in that: The distributed cluster method also includes a peer-to-peer mode; in the peer-to-peer mode, each node can create a rendering task and broadcast the created task information to other nodes in the network. Each node is matched with the rendering task to be executed based on its current resource status and priority.

6. The distributed rendering task scheduling method based on dynamic load balancing according to claim 1, characterized in that: Also includes: The rendering data stream is synchronized and the intermediate data in the data transmission process is compressed; the synchronization includes task allocation synchronization, state synchronization, and data synchronization.

7. The distributed rendering task scheduling method based on dynamic load balancing according to claim 1, characterized in that: Also includes: The rendering results can be previewed in real time through the visual terminal, and the rendering strategy can be automatically adjusted according to the rendering results to form a closed feedback loop.

Images