Switchable multi-runtime Serverless system

Abstract

The invention provides a switchable Serverless system with a plurality of runtime functions. The switchable Serverless system comprises a server and a server, the system comprises an empty basic environment, a runtime mounting mechanism, a multi-runtime manager, a runtime switching module and a performance optimization module. The null basic environment does not contain a specific programming language or runtime, the runtime mounting mechanism is used for dynamically mounting different runtime, the multi-runtime manager supports simultaneous operation of multiple runtime environments, the runtime switching module realizes rapid switching, and the performance optimization module reduces the influence on the system performance. The system further comprises a version control module, a compatibility check module, a monitoring module, an automatic selection module and the like, and a unified API adaptation layer. The method has the beneficial effects that the flexibility and the expandability of the Serverless architecture are improved, meanwhile, the performance close to the original runtime is kept, and a more efficient and freer Serverless computing environment is provided for developers.

Description

Technical Field

[0001] The present invention relates to the field of cloud computing technology, and in particular to a runtime management system in a Serverless architecture. Specifically, the present invention provides a Serverless system that can dynamically switch and coexist multiple runtime environments, so as to improve the flexibility and efficiency of cloud function execution. Background Art

[0002] As an important branch of cloud computing, Serverless architecture has played an important role in application development and deployment in recent years. This architecture model allows developers to focus on writing and running application code without having to manage the underlying infrastructure, which greatly improves development efficiency and resource utilization. In the Serverless architecture, the runtime environment is a key component for executing cloud functions, which directly affects the performance, compatibility, and scalability of the application.

[0003] Currently, the Serverless platform mainly uses three runtime solutions: specific programming language runtime, custom runtime and container image. Specific programming language runtime is usually provided by the platform, such as Node.js, Python, etc., with good performance and stability. Custom runtime allows users to define a specific execution environment, providing greater flexibility. Container image achieves the greatest degree of customization by packaging a complete runtime environment.

[0004] However, each of these solutions has some problems. Although specific programming language runtimes have excellent performance, they are slow to update and can easily become technical debt. Custom runtimes provide more options, but may result in a slight decrease in performance. Although container images are the most flexible, they often bring significant performance losses. In addition, these solutions usually require the selection of the runtime environment at the time of deployment, which is difficult to switch dynamically according to needs, limiting the flexibility and adaptability of serverless applications.

[0005] To solve the above problems, some studies have proposed the concept of dynamic runtime management. These methods attempt to dynamically load different execution environments at runtime to improve the flexibility of the system. Although these methods have improved the variability of the runtime to a certain extent, there are still problems such as high performance overhead and difficulty in supporting the coexistence of multiple runtimes. At the same time, these solutions often require a major transformation of the existing Serverless platform, which increases the difficulty and cost of implementation.

[0006] Therefore, there is an urgent need for a serverless runtime management system that can flexibly switch and coexist with multiple runtime environments while maintaining high performance and easy integration. Such a system can not only improve the adaptability and efficiency of serverless applications, but also provide developers with greater freedom, becoming an important direction for promoting the further development of serverless technology. Summary of the invention

[0007] The purpose of the present invention is to solve the problem of lack of flexibility and switchability of runtime environment in the existing Serverless architecture. Specifically, the present invention aims to overcome the defects such as slow update of specific programming language runtime, slightly reduced performance of custom runtime, and obvious performance loss of container image. In addition, the present invention also aims to provide a solution that can support the coexistence of multiple runtime environments at the same time to enhance the adaptability and efficiency of Serverless applications.

[0008] To achieve the above objectives, the present invention provides a switchable multi-runtime Serverless system, which is characterized by comprising an empty basic environment, a runtime mounting mechanism, a multi-runtime manager, a runtime switching module and a performance optimization module.

[0009] The system implements a highly flexible and efficient Serverless computing architecture by dynamically mounting and managing multiple runtime environments. In some embodiments, the system also includes functional modules such as version control, compatibility checking, monitoring and automatic selection, as well as a unified API adaptation layer, which further improves the system's availability and integration capabilities.

[0010] Specifically, the empty basic environment of the present invention does not include any specific programming language or runtime, and provides a basic platform for dynamically mounting different runtimes.

[0011] Furthermore, the runtime mounting mechanism includes a runtime library and a mounting controller, which are used to manage the mounting and unmounting process of the runtime module, thereby realizing dynamic loading of the runtime environment.

[0012] Preferably, the multi-runtime manager includes a runtime isolation module and a resource allocation module to ensure resource isolation between different runtime environments and to dynamically allocate and manage system resources.

[0013] Optionally, the runtime switching module includes a context saving module and a context restoring module, which are used to quickly switch between different runtimes, thereby ensuring state consistency during the switching process.

[0014] In one embodiment, the performance optimization module includes a preloading mechanism and a caching mechanism, which significantly improves the response speed and efficiency of the system by preloading commonly used runtime components and caching recently used runtime environments.

[0015] In certain embodiments, the present invention further includes a runtime version control module for managing runtime environments of different versions to facilitate system upgrades and maintenance.

[0016] In addition, the present invention may also include a runtime compatibility check module for verifying the compatibility of the newly mounted runtime with the existing system to ensure the stability of the system.

[0017] In other embodiments, the present invention also includes a runtime monitoring module and an automatic runtime selection module, which can monitor the performance and resource usage of each runtime environment in real time, and automatically select the most suitable runtime environment according to application requirements and system load.

[0018] In a preferred embodiment, the system of the present invention uses an empty basic environment as the underlying platform and uses a runtime mounting mechanism to dynamically load the required runtime environment. The multi-runtime manager ensures that multiple runtime environments can coexist and run efficiently, while the runtime switching module enables fast switching between different environments. The performance optimization module minimizes the performance overhead of the switching and loading process through preloading and caching mechanisms.

[0019] In another preferred embodiment, the system also integrates an API adaptation layer to provide a unified interface, so that different runtime environments can be seamlessly integrated into the existing Serverless architecture, greatly improving the compatibility and scalability of the system.

[0020] By adopting the above scheme, the present invention has the following beneficial effects: (1) It realizes dynamic loading and fast switching of multiple runtime environments, greatly improving the flexibility and adaptability of Serverless applications; (2) Supports the coexistence of multiple runtime environments, meets the needs of complex application scenarios, and improves resource utilization efficiency; (3) Through the performance optimization module, the performance overhead of runtime switching and loading is minimized, maintaining high performance close to that of the native runtime; (4) Provides comprehensive version control, compatibility checking and monitoring functions, enhancing the reliability and maintainability of the system; (5) The unified API adaptation layer simplifies integration with existing Serverless platforms and reduces adoption costs.

[0021] In summary, the present invention provides a highly flexible, efficient and easy-to-integrate Serverless runtime management system, which effectively solves the limitations of the prior art and provides important support for the further development and application of the Serverless architecture. BRIEF DESCRIPTION OF THE DRAWINGS

[0022] In order to more clearly illustrate the technical solution of the present invention, the following briefly introduces the drawings required for use in the embodiments. Obviously, the drawings described below are only some embodiments of the present invention, and for those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative work.

[0023] Figure 1 is a diagram of the basic system architecture.

[0024] Figure 2 is a diagram of the runtime mounting mechanism.

[0025] Figure 3 is a diagram of the multi-runtime manager.

[0026] Figure 4 is a diagram of the runtime switching module.

[0027] Figure 5 is a diagram of the performance optimization module.

[0028] Figure 6 is a detailed diagram of the runtime mounting mechanism.

[0029] Figure 7 is a detailed diagram of the multi-runtime manager.

[0030] Figure 8 is a detailed structural diagram of the runtime switching module.

[0031] Figure 9 is a detailed structural diagram of the performance optimization module. DETAILED DESCRIPTION

[0032] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are only part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0033] In the description of the present invention, it should be noted that the terms "center", "up", "down", "left", "right", "vertical", "horizontal", "inside", "outside" and the like indicate directions or positional relationships based on the directions or positional relationships shown in the accompanying drawings, and are only for the convenience of describing the present invention and simplifying the description, and do not indicate or imply that the device or element referred to must have a specific direction, be constructed and operated in a specific direction, and therefore should not be understood as a limitation on the present invention.

[0034] Example 1: Basic system architecture.

[0035] 1 , the basic architecture of the switchable multi-runtime Serverless system 100 provided by the present invention includes the following core components: an empty basic environment 110, a runtime mounting mechanism 120, a multi-runtime manager 130, a runtime switching module 140, and a performance optimization module 150. These components work together to innovatively implement a highly flexible and efficient Serverless runtime management system.

[0036] The empty basic environment 110 is the basic platform of the system, which does not contain any specific programming language or runtime environment. This design breaks through the limitations of the traditional Serverless architecture and enables the system to flexibly load and run a variety of different runtime environments. The empty basic environment 110 is implemented using lightweight container technology, such as optimized containerization technology, to ensure fast startup and minimal resource usage.

[0037] The runtime mounting mechanism 120 is one of the core innovations of the system, which is responsible for dynamically loading and unloading different runtime environments. As shown in FIG2 , the runtime mounting mechanism 120 includes a runtime library 122 and a mounting controller 124. The runtime library 122 stores a plurality of predefined runtime modules, which can be runtimes of different programming languages ​​(such as Node.js, Python, Java, etc.) or customized runtime environments. The mounting controller 124 is responsible for managing the mounting and unloading process of these runtime modules.

[0038] The mount controller 124 uses dynamic loading technology to achieve fast loading of the runtime environment. When a specific runtime environment is needed, the mount controller 124 selects the corresponding module from the runtime library 122 and dynamically links it to the empty basic environment 110. This process is designed to be completed as quickly as possible to ensure fast environment switching and function execution.

[0039] The multi-runtime manager 130 is responsible for coordinating and managing multiple coexisting runtime environments. As shown in FIG3 , it includes a runtime isolation module 132 and a resource allocation module 134. The runtime isolation module 132 uses lightweight virtualization technologies, such as Linux namespaces and control groups (Cgroups), to create an independent execution space for each runtime environment to ensure resource isolation and security between different runtimes. The resource allocation module 134 is responsible for dynamically allocating and managing system resources, such as CPU, memory, and storage, to optimize the parallel execution efficiency of multiple runtime environments.

[0040] The runtime switching module 140 implements fast switching between different runtime environments. As shown in FIG4 , it includes a context saving module 142 and a context recovery module 144. When the runtime environment needs to be switched, the context saving module 142 captures the state information of the current runtime, including memory content, execution stack, etc., and saves it. The context recovery module 144 is responsible for restoring the previously saved state information after switching to the new runtime environment. This mechanism is intended to ensure that the execution state of the application can be accurately maintained and restored during the runtime switching process.

[0041] The performance optimization module 150 is a key component to ensure efficient operation of the system. As shown in FIG5 , it includes a preloading mechanism 152 and a caching mechanism 154. The preloading mechanism 152 loads the runtime components that may be needed in advance based on the usage pattern and prediction algorithm to reduce the loading time when actually needed. The caching mechanism 154 maintains a cache of the recently used runtime environment for fast recovery and reuse. Through these optimization measures, the system aims to significantly reduce the performance overhead of runtime switching and loading, approaching the execution efficiency of the native runtime.

[0042] The core innovation of this embodiment is that it realizes real on-demand loading and fast switching of runtime environments through an empty basic environment and a dynamic mounting mechanism. Compared with the traditional pre-installed runtime or complete container image method, this system has the potential to significantly improve resource utilization efficiency and flexibility.

[0043] In addition, the system is designed with scalability and compatibility in mind. By defining standardized runtime interface specifications, the system can easily integrate new runtime environments or custom runtimes without modifying the core architecture. This design not only provides a solid foundation for future technological evolution, but also has the potential to greatly reduce the cost of developers adapting to different Serverless platforms.

[0044] It should be noted that the specific implementation described in this embodiment is only exemplary, and those skilled in the art can make appropriate modifications and adjustments according to actual needs. For example, the empty basic environment can use other lightweight virtualization technologies, the runtime mounting mechanism can use different dynamic loading strategies, and the multi-runtime manager can use other resource scheduling algorithms. These changes will not deviate from the core concept and protection scope of the present invention.

[0045] Embodiment 2: Runtime mounting mechanism.

[0046] 6, this embodiment describes in detail the specific implementation of the runtime mounting mechanism 120. The runtime mounting mechanism 120 is one of the core innovations of the present invention, which implements dynamic loading and unloading of the runtime environment, providing a high degree of flexibility and efficiency for the system.

[0047] As shown in FIG6 , the runtime mounting mechanism 120 mainly includes two main components: a runtime library 122 and a mounting controller 124. The runtime library 122 further includes a runtime module storage 126 and a version management unit 128. The mounting controller 124 includes a dependency resolution unit 125 and a dynamic linking unit 127.

[0048] The core function of the runtime library 122 is to store and manage various runtime environment modules. The runtime module storage 126 uses an efficient compressed storage format to store the core components of various runtime environments (such as Node.js, Python, Java, etc.) in a modular manner. This modular storage method not only saves storage space, but also facilitates fast loading and updating.

[0049] The version management unit 128 is responsible for managing different versions of runtime modules. It maintains a version mapping table that records the different versions of each runtime environment and their corresponding module locations. This design enables the system to support multiple versions of runtime environments at the same time and meet the compatibility requirements of different applications.

[0050] The mount controller 124 is the core of the runtime mount mechanism and is responsible for the actual runtime environment loading process. When the system requires a specific runtime environment, the mount controller 124 will be triggered to start the loading process.

[0051] First, the dependency resolution unit 125 analyzes the requested runtime environment and its version, and determines the specific modules that need to be loaded based on the information provided by the version management unit 128. This process also includes resolving dependencies between modules to ensure that all necessary components can be loaded correctly.

[0052] Then, the dynamic link unit 127 starts the actual loading process. It uses an innovative "delayed loading" technique to load only the core components of the runtime environment and postpone the loading of other components until they are actually needed. This approach significantly reduces the initial loading time and memory usage.

[0053] The dynamic link unit 127 uses memory mapping (mmap) technology to directly map the runtime module to the address space of the process instead of traditional file I / O operations. This method not only speeds up the loading speed, but also enables multiple processes to share the same runtime module memory, further improving system efficiency.

[0054] To ensure security, the dynamic link unit 127 performs integrity checks during the loading process to ensure that the loaded module has not been tampered with. It also implements the address space layout randomization (ASLR) technology to increase the difficulty of potential attacks.

[0055] The runtime mounting mechanism 120 also implements an innovative "hot plug" function. When a runtime environment needs to be updated or replaced, the system can dynamically uninstall the old version and load the new version without interrupting other running environments. This process is atomic, ensuring the stability and reliability of the system.

[0056] A key advantage of this embodiment is its high scalability. By defining a standardized module interface, system administrators can easily add new runtime environments or customize runtimes without modifying the core system architecture. This design provides great flexibility for future technological evolution.

[0057] In addition, the runtime mount mechanism 120 also implements an intelligent cache system. It predicts the runtime environment that may be needed based on historical usage patterns and preloads it into memory. This further reduces the loading time when it is actually needed and improves the responsiveness of the system.

[0058] It should be noted that although this embodiment describes a specific implementation, the protection scope of the present invention is not limited thereto. For example, other dynamic loading technologies may be used, different compression algorithms may be used, or other forms of version management strategies may be implemented. These changes or optimizations all fall within the protection scope of the present invention.

[0059] In summary, the runtime mounting mechanism 120 described in this embodiment provides an efficient, flexible, and secure runtime environment management solution for the Serverless system, effectively solving the problem of fixed runtime environment and difficulty in dynamic adjustment in the traditional Serverless architecture, and laying the foundation for building a more flexible and efficient Serverless platform.

[0060] Embodiment 3: Multiple runtime management.

[0061] 7 , this embodiment describes in detail the specific implementation of the multi-runtime manager 130. The multi-runtime manager 130 is another core innovation of the present invention, which enables the coexistence and efficient management of multiple runtime environments, providing unprecedented flexibility and resource utilization efficiency for the Serverless system.

[0062] As shown in FIG. 7 , the multi-runtime manager 130 mainly includes four main components: a runtime isolation module 132 , a resource allocation module 134 , a scheduler 136 , and a monitoring module 138 .

[0063] The runtime isolation module 132 is responsible for creating an independent execution space for each runtime environment to ensure isolation and security between different runtimes. This embodiment uses lightweight container technology to achieve isolation. Specifically, the runtime isolation module 132 uses Linux namespaces technology to create independent process, network and file system views, and uses control group (Cgroups) technology to limit the resource usage of each runtime environment. This method is lighter than traditional virtual machine isolation and provides sufficient security.

[0064] To further enhance security, the runtime isolation module 132 also implements an innovative "dynamic security policy" mechanism. This mechanism can dynamically adjust security policies according to the characteristics of the runtime environment and the type of function executed, such as adjusting system call filtering rules, network access permissions, etc. This fine-grained security control ensures the security of the system without excessively restricting legitimate operations.

[0065] The resource allocation module 134 is responsible for dynamically allocating and managing system resources, such as CPU, memory, and storage. It implements an innovative "elastic resource allocation" algorithm that dynamically adjusts resource allocation based on the real-time needs and priorities of each runtime environment. This algorithm takes into account multiple factors, including but not limited to: current system load, historical resource usage patterns, function execution priority, and expected execution time.

[0066] Resource allocation module 134 also implements "resource reservation" and "resource overage" mechanisms. Resource reservation ensures that critical runtime environments always have sufficient resources available, while resource overage allows non-critical environments to temporarily use more resources when system resources are sufficient, thereby improving overall resource utilization.

[0067] The scheduler 136 is the core component of the multi-runtime manager 130 and is responsible for coordinating the execution of multiple runtime environments. It implements an innovative "multi-level feedback queue" scheduling algorithm that can dynamically adjust the execution order and time slice allocation based on the execution characteristics (such as CPU intensiveness, I / O intensiveness) and priority of the function. This scheduling strategy ensures timely response of high-priority tasks and fully utilizes system resources.

[0068] The scheduler 136 also implements a "cooperative scheduling" mechanism. When a runtime environment temporarily does not need CPU resources (for example, waiting for an I / O operation to complete), it can actively give up the CPU to allow other runtime environments to execute. This mechanism significantly improves the efficiency of the system.

[0069] The monitoring module 138 is responsible for real-time monitoring of the performance and resource usage of each runtime environment. It collects a large number of performance indicators, including but not limited to: CPU usage, memory usage, network I / O, disk I / O, etc. These data are not only used to adjust resource allocation and scheduling strategies in real time, but also for long-term performance analysis and optimization.

[0070] The monitoring module 138 also implements an innovative "anomaly detection" algorithm that can promptly detect abnormal behaviors in the runtime environment, such as resource leaks, deadlocks, etc. Once an anomaly is detected, the system can automatically take corresponding measures, such as restarting the runtime environment or adjusting resource allocation to ensure the stability of the system.

[0071] An important feature of this embodiment is its high scalability. By defining standardized management interfaces, the system can easily integrate new isolation technologies, resource allocation algorithms, or scheduling strategies without modifying the overall architecture. This provides huge space for future technology evolution and performance optimization.

[0072] In addition, the multi-runtime manager 130 also implements an "adaptive learning" mechanism. The system continuously learns and analyzes the behavior patterns of the runtime environment and continuously optimizes resource allocation and scheduling strategies. This self-optimization capability allows the system to continuously improve its performance and efficiency over time.

[0073] It should be noted that although this embodiment describes a specific implementation, the protection scope of the present invention is not limited thereto. For example, other isolation technologies may be used, different resource allocation algorithms may be used, or other forms of scheduling strategies may be implemented. These changes or optimizations all fall within the protection scope of the present invention.

[0074] Embodiment 4: Switching modules at runtime.

[0075] 8 , this embodiment describes in detail the specific implementation of the runtime switching module 140. The runtime switching module 140 is another key innovation of the present invention, which enables fast and seamless switching between different runtime environments, greatly improving the flexibility and efficiency of the Serverless system.

[0076] As shown in FIG. 8 , the runtime switching module 140 mainly includes four main components: a context saving module 142 , a context recovery module 144 , a state manager 146 , and a switching scheduler 148 .

[0077] The context saving module 142 is responsible for capturing and saving the current runtime state information before switching the runtime environment. This process involves the following key steps.

[0078] Memory snapshot: Using incremental snapshot technology, only the memory pages that have changed since the last snapshot are saved. This greatly reduces the save time and storage space.

[0079] Execution stack preservation: capture the current execution stack information, including function call stack, local variables, etc.

[0080] Resource handle recording: Records all open file descriptors, network connections and other resource handles.

[0081] Environment variable save: Save the current environment variable settings.

[0082] The context saving module 142 also implements an innovative "selective saving" mechanism. According to the characteristics and execution status of the function, it can intelligently determine which information must be saved and which can be regenerated during recovery, thereby further optimizing the saving process.

[0083] The context recovery module 144 is responsible for restoring the previously saved state information after switching to a new runtime environment. Its main steps include:

[0084] Memory Reconstruction: Reload the saved memory snapshot into the new runtime environment.

[0085] Execution stack reconstruction: Rebuild the execution stack to ensure that the function can continue to execute from the interruption point.

[0086] Resource reconnection: Reestablish previously recorded resource connections, such as reopening files, reestablishing network connections, etc.

[0087] Environment variable restore: Restore previously saved environment variable settings.

[0088] The context recovery module 144 adopts a "delayed loading" strategy to load certain state information only when it is actually needed, which further reduces the switching time.

[0089] The state manager 146 is the core component of the runtime switching module 140 and is responsible for coordinating the context saving and recovery process. It implements an innovative "multi-version state management" mechanism that can save state snapshots at multiple time points at the same time. This mechanism enables the system to support more complex scenarios, such as quickly rolling back to a previous state or migrating states between multiple runtime environments.

[0090] The state manager 146 also implements state compression and encryption functions. State compression uses an efficient compression algorithm to further reduce storage space and transmission time. State encryption ensures the security of sensitive information during storage and transmission.

[0091] The switch scheduler 148 is responsible for coordinating the entire switch process and ensuring the atomicity and consistency of the switch operation. It implements a "two-phase commit" protocol, and can safely roll back to the previous state if an error occurs at any stage of the switch process.

[0092] The switch scheduler 148 also implements an innovative "predictive switch" mechanism. Based on historical data and current system status, it can predict the runtime environment that may be needed soon and start preparations in advance, such as preloading some status information, to further reduce the delay during the actual switch.

[0093] An important feature of this embodiment is its high degree of customizability. By providing a standardized interface, developers can define their own state preservation and recovery strategies for specific types of applications to meet special needs.

[0094] In addition, the runtime switching module 140 also implements an "adaptive optimization" mechanism. The system continuously monitors and analyzes the performance of the switching operation and automatically adjusts various parameters (such as snapshot frequency, compression level, etc.) to optimize the switching efficiency.

[0095] It should be noted that although this embodiment describes a specific implementation, the protection scope of the present invention is not limited thereto. For example, other state preservation technologies may be used, different compression or encryption algorithms may be used, or other forms of switching scheduling strategies may be implemented. These changes or optimizations all fall within the protection scope of the present invention.

[0096] Embodiment 5: Performance optimization module.

[0097] Referring to FIG9 , this embodiment describes in detail the specific implementation of the performance optimization module 150. The performance optimization module 150 is a key component of the present invention, which significantly improves the overall performance and efficiency of the system through a variety of innovative technologies. As shown in FIG9 , the performance optimization module 150 mainly includes four main components: a preloading mechanism 152, a cache mechanism 154, a cold start optimizer 156, and a resource predictor 158.

[0098] The preloading mechanism152 is responsible for intelligently preloading runtime components that may be needed to reduce the loading time when they are actually needed. The mechanism analyzes historical call data to identify runtime components and functions that are often used together, and predicts the components that will be needed based on the current system state and historical patterns. The preloading mechanism adopts a partial preloading strategy, preloading only the core components of the runtime environment and delaying the loading of other components until they are actually needed. In addition, the preloading mechanism also implements a dynamic adjustment algorithm that can automatically adjust the aggressiveness of preloading according to the accuracy of preloading and the status of system resources, so as to strike a balance between performance and resource consumption.

[0099] The cache mechanism 154 maintains a cache of recently used runtime environments for quick recovery and reuse. The mechanism implements a multi-level structure of memory cache and disk cache, balancing access speed and storage capacity. The cache replacement strategy uses an improved LRU (Least Recently Used) algorithm, which takes into account factors such as access frequency and loading cost to optimize the replacement of cache items. To improve resource utilization, the cache mechanism supports sharing the same runtime environment cache between multiple function instances. In addition, the cache mechanism also implements differential caching technology, which only stores the base version of the runtime environment and the differences between each specific version, greatly reducing storage space requirements while speeding up the switching speed between different versions.

[0100] The Cold Start Optimizer156 focuses on reducing the cold start time of functions, which is a key challenge in the Serverless architecture. The optimizer uses lightweight sandbox technologies such as gVisor to reduce environment preparation time. For frequently called functions, the Cold Start Optimizer pre-compiles to reduce runtime compilation overhead. In addition, it also pre-allocates some system resources, such as network connection pools, database connections, etc., to speed up the startup process. An innovation of the Cold Start Optimizer is the implementation of a progressive startup mechanism, which allows functions to start executing before they are fully ready, while continuing to complete the remaining initialization work in the background, significantly reducing the perceived startup delay.

[0101] Resource Predictor 158 is responsible for predicting system resource requirements and providing decision support for other components. It uses time series analysis and machine learning techniques to predict future load conditions, analyze resource usage patterns of different types of functions, and provide resource scaling recommendations based on the prediction results. The resource predictor uses a multi-model fusion approach, using multiple prediction models such as ARIMA and LSTM at the same time, and dynamically selects the most suitable model or combines the results of multiple models according to different situations to improve prediction accuracy.

[0102] An important feature of the performance optimization module 150 is its adaptive capability. It continuously monitors system performance and automatically adjusts the parameters of various optimization strategies based on the actual results, such as the aggressiveness of preloading, the size of the cache, the strategy for cold start optimization, etc. In addition, the performance optimization module also provides a performance tuning interface, allowing advanced users or system administrators to manually adjust the optimization parameters to suit specific application scenarios or requirements.

[0103] The performance optimization module 150 described in this embodiment provides a comprehensive performance optimization solution for the Serverless system, effectively solving various performance bottlenecks existing in the traditional Serverless architecture, such as cold start delay, low resource utilization efficiency, etc. Through these optimizations, the system can provide performance close to that of a traditional single runtime environment while maintaining flexibility, laying the foundation for building a high-performance and efficient Serverless platform.

[0104] It should be noted that although this embodiment describes a specific implementation, the protection scope of the present invention is not limited thereto. Other preloading algorithms may be used, different cache strategies may be used, or other forms of cold start optimization techniques may be implemented. These changes or optimizations all fall within the protection scope of the present invention.

[0105] Example 6: Version control and compatibility check.

[0106] This embodiment describes in detail the specific implementation of the version control module and the compatibility check module in the switchable multi-runtime Serverless system. These two modules work together to ensure that the system can effectively manage runtime environments of different versions and maintain the stability and reliability of the overall system.

[0107] The version control module adopts the design concept of a distributed version control system to maintain a complete version history for each runtime environment. The module uses semantic versioning to identify different versions of the runtime environment, making it easier for the system and developers to understand the differences and compatibility between versions. The version control module not only tracks the core components of the runtime environment, but also manages dependent libraries and configuration files.

[0108] In order to efficiently manage a large amount of version information, the version control module implements an incremental storage mechanism. This mechanism only stores the differences between versions, greatly reducing storage overhead. At the same time, the module also implements a fast version switching function, which can complete the switching of different versions of the runtime environment in milliseconds, which is particularly useful for scenarios that need to support multiple versions at the same time.

[0109] The compatibility check module is a key component to ensure system stability. It performs comprehensive compatibility testing every time the runtime environment is updated or a new version is introduced. This module implements a multi-level compatibility check mechanism: First, it performs static analysis to check whether the API of the new version of the runtime environment is compatible with the previous version. This includes checking changes in function signatures, return value types, exception handling, etc.

[0110] Secondly, the module performs dynamic testing, running a series of predefined test cases and typical application scenarios in the new version environment. These tests not only verify the functional correctness, but also check performance indicators to ensure that the new version does not cause performance degradation.

[0111] In particular, the compatibility check module implements a "progressive deployment" strategy. When a new version of the runtime environment is introduced, the system will first deploy it to a small number of instances and closely monitor its performance. Only after passing a series of rigorous compatibility and stability tests will the new version be promoted to more instances.

[0112] In order to deal with potential compatibility issues, the system also implements a "fast rollback" mechanism. If any abnormality is detected during the deployment process, the system can roll back to the previous stable version within seconds to minimize the impact on the service.

[0113] The version control module and the compatibility check module work closely together to maintain a "compatibility matrix". This matrix records in detail the compatibility relationship between different versions of the runtime environment, including multiple levels such as full compatibility, partial compatibility, and incompatibility. The system will refer to this matrix when selecting and updating versions to ensure that the selected version is compatible with the current system environment.

[0114] An important feature of this embodiment is its high degree of automation. The system can automatically perform most version control and compatibility checking tasks, greatly reducing the need for manual intervention. At the same time, the system also provides detailed logs and reports, allowing administrators to clearly understand the version status and compatibility of the system.

[0115] It should be noted that although this embodiment describes a specific version control and compatibility check mechanism, the protection scope of the present invention is not limited thereto. Other version management strategies may be adopted to implement different compatibility test methods, or other forms of deployment strategies may be used. These changes or optimizations all fall within the protection scope of the present invention.

[0116] In summary, the version control and compatibility check mechanism described in this embodiment provides powerful version management and system stability assurance for the switchable multi-runtime Serverless system. Through sophisticated version control, comprehensive compatibility checks, and intelligent deployment strategies, the system can ensure the operation of each component and the stability of the overall system while maintaining flexibility, laying the foundation for building a reliable Serverless platform.

[0117] Example 7: Monitoring and automated selection.

[0118] This embodiment describes in detail the specific implementation of the runtime monitoring module and the automatic runtime selection module in the switchable multi-runtime Serverless system. These two modules work together to achieve real-time monitoring of the system and intelligent runtime environment selection, greatly improving the system's operating efficiency and resource utilization.

[0119] The runtime monitoring module adopts a distributed monitoring architecture to collect performance indicators and operating status information at all levels of the system. The module uses lightweight Agent technology to implant monitoring probes in each runtime environment to collect key indicators such as CPU usage, memory usage, network I / O, and disk I / O in real time. In order to minimize the impact of monitoring on system performance, the monitoring module uses adaptive sampling rate technology to dynamically adjust the data collection frequency according to the system load.

[0120] The monitoring module not only collects raw performance data, but also implements complex indicator calculation and anomaly detection functions. For example, it can calculate advanced indicators such as function cold start time, execution delay, error rate, etc. By using machine learning algorithms such as anomaly detection and time series analysis, the monitoring module can detect performance anomalies and potential problems in a timely manner.

[0121] In order to effectively process and analyze large amounts of monitoring data, the system implements a high-performance time series database. This database is optimized to efficiently store and query large-scale time series data. In addition, the monitoring module provides flexible data aggregation and visualization capabilities, allowing system administrators to intuitively understand system status and performance trends.

[0122] The automatic runtime selection module is the core component of the system intelligence. It selects the most appropriate runtime environment for each function call based on the real-time data and historical performance indicators provided by the monitoring module. This module implements a multi-factor decision model that considers the following key factors.

[0123] Function characteristics: including the function's language type, resource requirements, execution time, etc.

[0124] Runtime performance: The current load and historical performance of each runtime environment.

[0125] System resource status: overall system resource utilization and availability.

[0126] User-defined policies: Allow users to set specific runtime preferences or restrictions.

[0127] The automated selection module uses a reinforcement learning algorithm that continuously learns and optimizes its decision-making strategy. The system records the results and performance feedback of each selection to adjust and improve future selections. This self-learning capability enables the system to adapt to changing workloads and operating environments.

[0128] To handle sudden high loads, the automatic selection module implements a "dynamic scaling" mechanism. It can predict changes in resource requirements and start new runtime instances or release idle resources in advance. This mechanism is seamlessly integrated with the cloud platform's automatic scaling function to ensure that the system can respond to load changes in a timely manner.

[0129] The automated selection module also includes an "A / B testing" feature. The system can run multiple different runtime selection strategies simultaneously and compare their performance. This allows the system to safely validate and optimize selection algorithms in a production environment.

[0130] The monitoring module and the automated selection module work closely together to form a closed-loop optimization system. For example, when the monitoring module detects that the performance of a runtime environment has degraded, it immediately notifies the automated selection module, which may temporarily reduce the use of the environment and trigger an investigation and remediation process.

[0131] An important feature of this embodiment is its high scalability and adaptability. The system provides a plug-in architecture that allows easy addition of new monitoring indicators and selection strategies. This enables the system to quickly adapt to new technology trends and application requirements.

[0132] It should be noted that, although this embodiment describes a specific monitoring and automatic selection mechanism, the protection scope of the present invention is not limited thereto. Other monitoring technologies may be used to implement different selection algorithms, or other forms of resource management strategies may be used. These changes or optimizations all fall within the protection scope of the present invention.

[0133] In summary, the monitoring and automated selection mechanism described in this embodiment provides intelligent runtime management capabilities for switchable multi-runtime Serverless systems. Through comprehensive real-time monitoring and intelligent selection based on machine learning, the system can always maintain optimal performance and resource utilization in a dynamically changing environment. This not only improves the overall efficiency of the system, but also provides users with a more stable and high-performance service experience, laying the foundation for building the next generation of intelligent Serverless platforms.

Claims

1. A switchable multi-runtime system for a Serverless architecture, characterized in that: include: An empty base environment, wherein the empty base environment does not include any specific programming language or runtime; A runtime mounting mechanism for dynamically mounting different runtimes into the empty basic environment; A multi-runtime manager to support mounting and running multiple different runtime environments simultaneously; A runtime switching module for fast switching between different runtimes; And a performance optimization module to optimize the runtime mounting and switching process to reduce the impact on system performance.

2. The system according to claim 1, characterized in that The runtime mounting mechanism includes: a runtime library for storing a plurality of predefined runtime modules; and a mounting controller for managing the mounting and unmounting process of the runtime modules.

3. The system according to claim 1, characterized in that The multi-runtime manager includes: a runtime isolation module for ensuring resource isolation between different runtime environments; and a resource allocation module for dynamically allocating and managing system resources.

4. The system according to claim 1, characterized in that The runtime switching module includes: a context saving module for saving the state of the current runtime before switching; and a context restoring module for restoring the state of the target runtime after switching.

5. The system according to claim 1, characterized in that Also includes: A runtime version control module for managing different versions of the runtime environment.

6. The system according to claim 1, characterized in that Also includes: A runtime compatibility check module that verifies the compatibility of a newly installed runtime with an existing system.

7. The system according to claim 1, characterized in that The performance optimization module includes: a preloading mechanism for preloading commonly used runtime components; and a caching mechanism for caching the most recently used runtime environment.

8. The system according to claim 1, characterized in that Also includes: A runtime monitoring module that monitors the performance and resource usage of each runtime environment in real time.

9. The system according to claim 1, characterized in that Also includes: An automatic runtime selection module that automatically selects the most suitable runtime environment based on application requirements and system load.

10. The system according to claim 1, characterized in that Also includes: An API adaptation layer that provides a unified interface so that different runtime environments can be seamlessly integrated into the existing Serverless architecture.

Images