Wasm deployment and efficient scheduling method and system based on remote compiling

Abstract

The invention provides a remote compilation-based Wasm deployment and efficient scheduling method and system, and relates to the field of computers, and the method comprises the following steps: obtaining a Wasm module; judging whether each subtask in the Wasm module is executed or not according to the historical compilation copy in the persistent memory; if the subtask is executed, obtaining a historical compiled copy of the subtask; if the sub-tasks are not executed, or the executed sub-tasks are searched for corresponding historical compiling copies, the system is updated in real time through cluster information, and a compiling strategy and a scheduling strategy are constructed; according to the method, the latest node information is read, the compiling strategy is combined, the Wasm module is compiled into the binary file, and the compiled binary file is distributed to the corresponding working node for calculation, so that Wasm deployment and scheduling based on remote compiling are realized, resource utilization maximization can be ensured, unnecessary compiling and transmission expenses are reduced, and the resource utilization rate is improved. Therefore, the efficiency and performance of the whole system are improved.

Description

Technical Field

[0001] The present application relates to the field of computers, and in particular to a Wasm deployment and efficient scheduling method and system based on remote compilation. Background Art

[0002] In recent years, the cloud computing landscape has changed from a centralized architecture consisting of large data centers to a distributed heterogeneous architecture that includes edge and IoT processing units. This transformation has promoted the birth of edge computing, and the gap between large data centers and terminal devices is slowly narrowing. However, with the rapid development of IoT technology, a large number of sensor devices have been deployed on the network side, and these devices have generated massive amounts of environmental data, posing severe challenges to data processing and network transmission. In order to effectively alleviate these pressures and improve the service quality of end-side services, some people have proposed using WebAssembly (Wasm), an efficient and lightweight container technology, to encapsulate and deploy some computing tasks on end devices to improve service response speed and reduce network transmission burden.

[0003] Wasm was originally designed as a general low-level bytecode, intended as a compiled target code for high-level programming languages ​​(C / C++, Rust, etc.) so that various applications implemented by high-level programming languages ​​can run efficiently in a Web environment. It has a compact binary format and runs in a stack-based sandbox environment. Wasm cannot directly access the operating system or hardware resources and can only interact with the external environment through predefined interfaces. This protects user services from malicious code and also eliminates the limitations of device differences on developers. Through the WebAssembly System Interface (WASI), Wasm can interact with the operating system and run as a standalone application on various computing devices. Therefore, Wasm is also a lightweight virtualization technology, which makes it possible to encapsulate computing tasks in some IoT applications into Wasm and deploy them on heterogeneous end-side devices.

[0004] From the above background, it can be seen that the execution of Wasm programs requires a Wasm runtime environment that supports WASI to complete the interaction with the operating system. At present, there are many Wasm runtimes in the open source community, such as Wasmer, WasmEdge, and Wasmtime. As a medium between Wasm programs and the operating system, the Wasm runtime first needs to compile the bytecode in the .Wasm file into binary code that can be executed on the target device.

[0005] Wasm modules can generally run in one of three compilation modes: interpreter, just-in-time (JIT), or ahead-of-time (AOT).

[0006] The interpreter strategy has a small memory footprint and takes up little space, but it executes relatively slowly.

[0007] The JIT strategy compiles the code as it executes, allowing Wasm to run at almost native speed while remaining platform-independent. However, compilation is resource-intensive to implement.

[0008] The AOT strategy completes compilation before code execution. It is conducive to quick startup and takes up very little space. Although it sacrifices a certain degree of operating efficiency, it reduces resource requirements and compiles faster.

[0009] However, the existing Wasm runtime, no matter which compilation method is used, is unacceptable for some IoT devices with extremely limited resources. The computing, storage and energy resources of some IoT devices are very limited, making it difficult to undertake complex compilation tasks, which greatly limits the flexibility of IoT applications.

[0010] Through AOT compilation, Wasm bytecode can be pre-compiled on a host computer with more abundant resources, and the generated binary code can be sent to the end device with the same hardware architecture for execution. Although this method reduces the running efficiency of the code to a certain extent, it allows the compilation results to be reused on multiple end devices, reducing the resource consumption of compilation. JIT compilation requires separate compilation on each end device. Although it can provide higher running efficiency, not all end devices have sufficient resources to perform compilation. Summary of the invention

[0011] The purpose of the present invention is to provide a Wasm deployment and efficient scheduling method and system based on remote compilation in order to solve the problem that the existing compilation method of Wasm programs cannot be applied to IoT devices with extremely limited resources.

[0012] The above-mentioned purpose of the present application is achieved through the following technical solutions: S1: Get the Wasm module; build a registry-based cluster information real-time update system and persistent storage; S2: Determine whether each subtask in the Wasm module has been executed based on the historical compilation copy in the persistent storage; If the subtask has been executed, obtain the historical compiled copy of the subtask and use it as the compiled binary file; If the subtask has not been executed, or the executed subtask is not a corresponding historical compilation copy, the system is updated in real time through cluster information to build a compilation strategy; the latest cluster information in the system is updated in real time through cluster information to obtain a scheduling strategy; S3: Read the latest node information from the registry, and compile the Wasm module into a binary file based on the AOT compilation method and compilation strategy; S4: Combined with the scheduling strategy and node information, the compiled binary files are distributed to the corresponding working nodes for calculation, realizing Wasm deployment and scheduling based on remote compilation.

[0013] Optionally, step S3 includes: The node information and subtasks without historical compilation copies in the Wasm module are packaged and submitted to the Wasm compilation queue. Combined with the AOT compilation method and compilation strategy, the compilation operation is performed to obtain the latest compiled binary file; Combine the historical compiled copy and the latest compiled binary file into a binary file compiled by the Wasm module.

[0014] Optionally, step S3 further includes: Update the node information in the registry through the compiled Wasm module.

[0015] Optionally, step S3 further includes: Store the compiled Wasm module to a persistent storage device as a historical compilation copy.

[0016] Optionally, step S3 includes: The node information and Wasm module are packaged and submitted to the Wasm compilation queue, and the compilation operation is performed in combination with the AOT compilation method and compilation strategy.

[0017] Optionally, step S4 includes: After the working node completes the calculation, the computing resources of the working node are released and the calculation results are obtained; According to the calculation results, the node information in the registration table is updated again.

[0018] The beneficial effects of the technical solution provided by this application are: Select appropriate compilation strategies for Wasm programs, compile Wasm modules into binary files suitable for the target platform in a host computer with sufficient resources, and then distribute these files to the corresponding nodes to give full play to the computing potential of the end devices and improve service quality. In Wasm deployment and scheduling, node information is updated in real time, and compiled Wasm modules are saved for the next compilation, which improves compilation efficiency. BRIEF DESCRIPTION OF THE DRAWINGS

[0019] The present application will be further described below with reference to the accompanying drawings and embodiments, in which: Figure 1 is a system structure diagram in an embodiment of the present application; Figure 2 This is a test result diagram based on WasmTime runtime in an embodiment of the present application; Figure 3 It is a test result diagram based on Wasmer runtime in an embodiment of the present application; Figure 4 This is a test result diagram based on WasmEdge runtime in an embodiment of the present application. DETAILED DESCRIPTION

[0020] In order to have a clearer understanding of the technical features, purposes and effects of the present application, the specific implementation methods of the present application are now described in detail with reference to the accompanying drawings.

[0021] The embodiments of the present application provide a Wasm deployment and efficient scheduling method based on remote compilation.

[0022] Please refer to Figure 1 , Figure 1 It is a system structure diagram of a Wasm deployment and efficient scheduling method based on remote compilation in an embodiment of the present application, including: S1: Get the Wasm module; build a registry-based cluster information real-time update system and persistent storage; S2: Determine whether each subtask in the Wasm module has been executed based on the historical compilation copy in the persistent storage; If the subtask has been executed, obtain the historical compiled copy of the subtask and use it as the compiled binary file; If the subtask has not been executed, or the executed subtask is not a corresponding historical compilation copy, the system is updated in real time through cluster information to build a compilation strategy; the latest cluster information in the system is updated in real time through cluster information to obtain a scheduling strategy; As an embodiment, when a Wasm module arrives at the host computer and needs to be scheduled to be executed on a cluster node, the host computer will first check whether the same task has been executed before. When the same task has been executed, the AOT-compiled copy is found in the local persistent storage device, so the compilation step can be omitted, and the corresponding copy file can be directly extracted to schedule the task. If there is no corresponding copy saved locally, the host computer will implement the compilation strategy of the Wasm module based on a cluster information real-time update system implemented by a registry, because different system architectures and Wasm runtimes will affect whether the Wasm module after AOT compilation can run normally. When the compilation strategy and scheduling strategy are determined, the host computer reads the relevant node information from the registry and packages it with the Wasm module and submits it to the Wasm compilation queue for compilation, and updates the information of the corresponding node in the registry at the same time. After AOT compilation, the compilation stack will submit the compiled Wasm module information and node information to the scheduler. The scheduler will distribute the Wasm module to the corresponding working node for execution and return the AOT compiled Wasm module information to the host computer. The host computer will update the registry again and store the compiled Wasm module in the persistent storage device.

[0023] S3: Read the latest node information from the registry, and compile the Wasm module into a binary file based on the AOT compilation method and compilation strategy; S4: Combined with the scheduling strategy and node information, the compiled binary files are distributed to the corresponding working nodes for calculation, realizing Wasm deployment and scheduling based on remote compilation.

[0024] As an embodiment, a decision is made on the compilation strategy of the Wasm module. The factors that affect the scheduling system strategy are described below.

[0025] 1. Differences in the amount of resources on the end devices: Although Wasm can eliminate the limitations caused by differences in the architecture of different devices, it is still limited by the device resources. These resources include the device's memory size, hard disk space, bandwidth, number of CPU cores, etc. Therefore, when deploying a Wasm module, you need to first obtain device information through the end device's agent. If the resource demand of the Wasm module exceeds the device's resource inventory, then the device cannot become a deployment node.

[0026] 2. The impact of communication time: In a distributed system, the time of information transmission is an important factor affecting the total execution time of the application. For computing tasks encapsulated in Wasm, in addition to the impact of communication time, the compilation strategy is also an important factor affecting the execution time. If JIT is used, the execution efficiency is high, but it consumes resources and can only be released for compilation on the end device; if AOT is used, the execution efficiency is low, but remote compilation can be performed and it can be executed on some resource-constrained devices to improve the efficiency of the cluster; therefore, the joint impact of compilation, communication and execution time should be comprehensively considered to select the optimal deployment and compilation strategy.

[0027] As an embodiment, first, the execution of the Wasm module needs to be performed on a node in the cluster. By default, the Wasm runtime on the node will use interpretation or JIT (Just-in-Time Compilation) to execute the module. The execution speed of interpretation execution is slow, so JIT is generally used to speed up the execution process. JIT significantly improves performance by dynamically obtaining runtime information and performing complex optimizations. However, this execution method has a large demand for memory, so it is necessary to ensure that the target node has sufficient flash and memory capacity to support JIT compilation and calculation. In addition, the JIT strategy requires a "warmup" phase to collect enough runtime information. During this warm-up period, the JIT compiler observes tens of thousands of code executions, collects class hierarchy diagrams, code branches, and type information, etc., in order to make better optimization decisions and achieve performance improvement. Compared with JIT, the AOT (Ahead of Time Compilation) strategy compiles the Wasm module into machine code that can be executed directly in the Wasm runtime. Programs compiled by AOT have smaller memory usage and faster startup and execution speeds. However, since AOT compilation is performed before the program runs, the entire code needs to be compiled into machine code in advance, which results in a long compilation time and the size of the compiled program will vary. At the same time, AOT compilation requires the architecture information of the target node, because the generated machine code is bound to a specific operating system and platform hardware, which makes AOT less flexible than JIT. In view of the characteristics and differences between JIT and AOT, the AOT compilation process is decoupled from the execution process. Specifically, the compilation process is placed on a host computer with more resources, and then the compilation results are distributed to the working nodes for execution to improve execution efficiency. For the AOT strategy, the total time of the Wasm module from scheduling to completion of execution includes: the time for the module to be transmitted to the host computer, the compilation time, the time for the compilation results to be transmitted to the working node, the execution time, and the result return time. In this way, while ensuring execution efficiency, the dependence on the resources of a single working node can be reduced.

[0028] Step S3 includes: The node information and subtasks without historical compilation copies in the Wasm module are packaged and submitted to the Wasm compilation queue. Combined with the AOT compilation method and compilation strategy, the compilation operation is performed to obtain the latest compiled binary file; Combine the historical compiled copy and the latest compiled binary file into a binary file compiled by the Wasm module.

[0029] Step S3 also includes: Update the node information in the registry through the compiled Wasm module.

[0030] Step S3 also includes: Store the compiled Wasm module to a persistent storage device as a historical compilation copy.

[0031] Step S3 includes: The node information and Wasm module are packaged and submitted to the Wasm compilation queue, and the compilation operation is performed in combination with the AOT compilation method and compilation strategy.

[0032] Step S4 includes: After the working node completes the calculation, the computing resources of the working node are released and the calculation results are obtained; According to the calculation results, the node information in the registration table is updated again.

[0033] As an example, after the working node completes the computing task, it returns the result to the scheduler, and the scheduler returns the corresponding Wasm module information to the host computer for the second time, indicating that the computing task of the relevant node is completed and the computing resources have been released. At the same time, the host computer updates the registration table for the last time based on the corresponding information and returns the calculation result.

[0034] A Wasm deployment and efficient scheduling system based on remote compilation, the system comprising: a Wasm acquisition module, a cluster information real-time update module based on a registry, a storage module, a host computer, a scheduler, and a node network of terminal devices; The Wasm acquisition module is used to obtain the Wasm module, that is, to obtain the Wasm program; The cluster information real-time update module based on the registry is used to build a cluster information real-time update system based on the registry; The storage module is used to build persistent storage; The host computer is used to determine whether each subtask in the Wasm module has been executed based on the historical compilation copy in the persistent storage; if the subtask has been executed, the historical compilation copy of the subtask is obtained and used as the compiled binary file; if the subtask has not been executed, or the executed subtask has not retrieved the corresponding historical compilation copy, the system is updated in real time through cluster information to build a compilation strategy; the latest cluster information in the system is updated in real time through cluster information to obtain the scheduling strategy; The host computer is also used to read the latest node information from the registry, and compile the Wasm module into a binary file in combination with the AOT compilation method and compilation strategy; The host computer is also used to submit the compiled binary files and node information to the scheduler; The scheduler is used to combine scheduling strategies and node information to distribute binary files to various end devices in the node network for calculation, thereby realizing Wasm deployment and scheduling based on remote compilation.

[0035] The system further comprises: The Wasm acquisition module, the registry-based cluster information real-time update module, the storage module, and the scheduling machine are all connected to the host computer; Node network connection scheduler for end devices.

[0036] In one embodiment, the key points of this application are as follows: 1. Cluster information real-time update system The scheduling algorithm of this application is based on real-time updated cluster information (including node information). Therefore, when designing a scheduling system, how to maintain node and network information and provide decision support for the host computer needs to be given priority.

[0037] The scheduler makes scheduling strategies based on the cluster information in the registry, and maintains the registry in real time based on the scheduling strategies of the Wasm module. Libvirt, a set of open source APIs, daemons, and management tools for managing hardware virtualization, is used in the host computer to manage and maintain cluster-side devices. An Agent client program is implemented on the end device. When the scheduler sends the Wasm module to the node and accepts changes to the node resource information, it interacts with the Agent client, such as Figure 1 shown.

[0038] Whenever a Wasm module compiled by AOT needs to be deployed by the scheduler, the scheduler will first access the cluster information registry in the host computer and select a suitable end device according to the scheduling algorithm. Then the scheduler will send the Wasm module to the corresponding end device and submit the deployment information to the host computer to update the registry in real time. The registry stores the information of the end device, such as the remaining memory, the remaining flash memory size, RTT (the time it takes for a data packet to be sent out and returned), the bandwidth size, and the Wasm runtime and architecture information. The nodes are sorted according to the remaining memory size. When the scheduler deploys the Wasm module to the end device, the deployment information will be sent back to the host computer. The registry will update the registry information of the corresponding node according to the memory capacity required by the Wasm module, the file size, and the recent RTT with the node, and re-sort the position of the corresponding node in the registry. In this way, the real-time update of cluster information when deploying the Wasm module is completed. When the end device returns the execution result to the host computer, the computing resources occupied by the current computing task will be released. The host computer will also update the information of the corresponding node in the registry and re-sort it. This is the real-time update of cluster information after the Wasm module completes the computing task.

[0039] 2. Wasm deployment and scheduling strategy based on remote compilation The present invention selects to compile the Wasm module into a binary file suitable for the target platform in a resource-sufficient host computer, and then distributes these files to the corresponding platform. This method reduces the resource consumption of repeated compilation on the end device, so that the end device can invest more resources in the actual calculation process, thereby improving the execution efficiency. It was found during the experiment that the AOT compilation performed by different Wasm runtimes cannot be run in a cross-runtime environment, so it is necessary to first know the Wasm runtime and node architecture information of the target end device when performing AOT compilation. At the same time, the size of the Wasm bytecode file after AOT compilation will change, which is the same Wasm bytecode that has been AOT compiled. If found, the node with the same Wasm runtime and architecture information in the registry will be searched first. If the node resources are sufficient, the machine code will be directly sent to the node for execution. If there is no corresponding node, the scheduler starts with the node with the most remaining resources, accesses the registry in positive order, compares whether the current node has enough resources for task scheduling, and records the node with the smallest communication delay and the reciprocal of the bandwidth until the first node with insufficient resources is encountered.

[0040] Then, the scheduler will add the Wasm module to the compilation queue to prepare for AOT compilation, and provide the node architecture information that records the sum of the minimum communication delay and the inverse of the bandwidth to the AOT compiler in the host computer for specified compilation. The compiled bytecode file will be retained in the host computer's persistent storage device for 24 hours. If it is reused within the retention time, the retention time will be refreshed. After the retention time exceeds, the corresponding bytecode file will be cleared. After the compilation is completed, the host computer sends the target machine code to the corresponding node and waits for the calculation result to be returned.

[0041] This strategy can ensure maximum resource utilization while reducing unnecessary compilation and transmission overhead, thereby improving the efficiency and performance of the entire system.

[0042] In order to evaluate the performance of the Wasm deployment and scheduling system based on remote compilation, a series of experiments were conducted on a node network consisting of several Raspberry Pis. The following are the detailed steps and results of the experiment: 1. Experimental environment and tool selection: Three of the most popular Wasm runtime environments were selected: WasmEdge, WasmTime, and Wasmer.

[0043] Three algorithms were selected from the polybench / C benchmark suite for testing: 2mm (matrix multiplication), LU decomposition, and fdtd-apml (FDTD algorithm with absorbing boundary conditions).

[0044] 2. Compilation and test benchmarks: Use the emcc compiler to compile operators written in C language into .Wasm bytecode files.

[0045] In order to intuitively demonstrate the operating efficiency of the Wasm module, the execution efficiency of the C file directly compiled into the machine code (Native) program is used as a test benchmark.

[0046] 3. Test plan: The effects of different Wasm runtimes on the execution efficiency of Wasm modules were tested when using a deployment and scheduling strategy based on remote compilation and when not using this strategy (i.e., a strategy of direct execution through JIT).

[0047] 4. Experimental results: The experimental results are as follows Figures 2 to 4 As shown in the figure, AOT / Native represents the ratio of the experimental results of this solution to the machine code execution time, and JIT / Native represents the ratio of the just-in-time compilation strategy used by the Wasm runtime when executing the Wasm module to the machine code execution time by default. Figure 2 , Figure 3 and Figure 4 It can be seen that the strategy of this solution decouples the compilation process from the execution process through remote compilation, and after adopting distributed deployment, the execution efficiency of most algorithms in different Wasm runtime environments has been improved to varying degrees.

[0048] Especially in the WasmEdge runtime environment, the execution efficiency after calling remote compilation is reduced by hundreds of times compared to the execution time when it is not called.

[0049] However, when testing the 2mm algorithm in the WasmTime runtime, the JIT execution strategy is a bit faster (e.g. Figure 1 ), the reason for this is that in the WasmTime runtime environment, the 2mm algorithm is slower than JIT when executed using the AOT strategy. Under the strategy of this solution, the Wasm module file of the 2mm algorithm after AOT compilation is larger, which leads to a longer transmission time, so Figure 1 The situation in.

[0050] 5. Performance improvement in case of traffic surge: In the case of a surge in traffic, Wasm modules will have more opportunities to reuse machine code files that have been AOT-compiled, omitting the compilation step and achieving greater execution efficiency.

[0051] In summary, the experiment verified the effectiveness of the Wasm deployment and scheduling system based on remote compilation in improving execution efficiency, especially under high load conditions, the system can further improve performance by reusing precompiled machine code files. These results provide strong evidence support for the deployment and scheduling of Wasm in resource-constrained environments.

[0052] The above are only exemplary embodiments of the present disclosure and cannot be used to limit the scope of the present disclosure. That is, any equivalent changes and modifications made according to the teachings of the present disclosure are still within the scope of the present disclosure.

[0053] This application is intended to cover any variation, use or adaptation of the present disclosure, which follows the general principles of the present disclosure and includes common knowledge or customary technical means in the art not described in the present disclosure. The description and examples are to be regarded as exemplary only, and the scope and spirit of the present disclosure are defined by the claims.

Claims

1. A Wasm deployment and efficient scheduling method based on remote compilation, characterized in that: The method comprises the following steps: S1: Get the Wasm module; build a registry-based cluster information real-time update system and persistent storage; S2: Determine whether each subtask in the Wasm module has been executed based on the historical compilation copy in the persistent storage; If the subtask has been executed, obtain the historical compiled copy of the subtask and use it as the compiled binary file; If the subtask has not been executed, or the executed subtask has not retrieved the corresponding historical compilation copy, the system is updated in real time through cluster information to build a compilation strategy; Update the latest cluster information in the system in real time through cluster information to obtain the scheduling strategy; S3: Read the latest node information from the registry, and compile the Wasm module into a binary file based on the AOT compilation method and compilation strategy; S4: Combined with the scheduling strategy and node information, the compiled binary files are distributed to the corresponding working nodes for calculation, realizing Wasm deployment and scheduling based on remote compilation.

2. A Wasm deployment and efficient scheduling method based on remote compilation as claimed in claim 1, characterized in that: Step S3 includes: The node information and subtasks without historical compilation copies in the Wasm module are packaged and submitted to the Wasm compilation queue. Combined with the AOT compilation method and compilation strategy, the compilation operation is performed to obtain the latest compiled binary file; Combine the historical compiled copy and the latest compiled binary file into a binary file compiled by the Wasm module.

3. A Wasm deployment and efficient scheduling method based on remote compilation as claimed in claim 1, characterized in that: Step S3 also includes: Update the node information in the registry through the compiled Wasm module.

4. A Wasm deployment and efficient scheduling method based on remote compilation as claimed in claim 1, characterized in that: Step S3 also includes: Store the compiled Wasm module to a persistent storage device as a historical compilation copy.

5. A Wasm deployment and efficient scheduling method based on remote compilation as claimed in claim 1, characterized in that: Step S3 includes: The node information and Wasm module are packaged and submitted to the Wasm compilation queue, and the compilation operation is performed in combination with the AOT compilation method and compilation strategy.

6. A Wasm deployment and efficient scheduling method based on remote compilation as claimed in claim 1, characterized in that: Step S4 includes: After the working node completes the calculation, the computing resources of the working node are released and the calculation results are obtained; According to the calculation results, the node information in the registration table is updated again.

7. A Wasm deployment and efficient scheduling system based on remote compilation, used to implement a Wasm deployment and efficient scheduling method based on remote compilation as described in any one of claims 1-6, characterized in that: The system includes: a Wasm acquisition module, a cluster information real-time update module based on a registry, a storage module, a host computer, a scheduler, and a node network of terminal devices; The Wasm acquisition module is used to obtain the Wasm module, that is, to obtain the Wasm program; The cluster information real-time update module based on the registry is used to build a cluster information real-time update system based on the registry; The storage module is used to build persistent storage; The host computer is used to determine whether each subtask in the Wasm module has been executed based on the historical compilation copy in the persistent storage; if the subtask has been executed, the historical compilation copy of the subtask is obtained and used as the compiled binary file; if the subtask has not been executed, or the executed subtask has not retrieved the corresponding historical compilation copy, the system is updated in real time through cluster information to build a compilation strategy; the latest cluster information in the system is updated in real time through cluster information to obtain a scheduling strategy; The host computer is also used to read the latest node information from the registry, and compile the Wasm module into a binary file in combination with the AOT compilation method and compilation strategy; The host computer is also used to submit the compiled binary files and node information to the scheduler; The scheduler is used to combine scheduling strategies and node information to distribute binary files to various end devices of the node network for calculation, realizing Wasm deployment and scheduling based on remote compilation.

8. A Wasm deployment and efficient scheduling system based on remote compilation as described in any one of claim 7, characterized in that: The system further comprises: The Wasm acquisition module, the registry-based cluster information real-time update module, the storage module, and the scheduling machine are all connected to the host computer; Node network connection scheduler for end devices.

Images