Function resource management method, system, device and medium of server unconscious framework

Abstract

The application discloses a function resource management method, system and device of a server non-sensing framework and a medium. The method separates read requests and write requests based on a function resource scheduling request by obtaining the function resource scheduling request, and obtains separated read requests and separated write requests. The separated write requests are sent to multiple on-demand function instances, and the separated write requests are processed by the multiple on-demand function instances. Multiple constraint conditions are constructed, and multiple bidding function instances satisfying the multiple constraint conditions are selected. The separated read requests are sent to the multiple bidding function instances, and the separated read requests are processed by the multiple bidding function instances, so as to realize function resource management of the server non-sensing framework. The application can reduce function communication cost and improve overall computing performance of a workflow, and can avoid performance decline caused by excessive load of a single function node and reduce computing cost.

Description

Technical Field

[0001] This invention relates to the field of cloud computing technology, and in particular to a method, system, device, and medium for function resource management within a server-insensitive framework. Background Technology

[0002] Existing server-side seamless frameworks for function composition scheduling mostly rely on brief information about the function's region to implement scheduling strategies. By centrally calling functions within the same region or by statically predefining functions at the code level, they improve data locality and reduce transmission latency, making them suitable for various application scenarios, especially in large-scale, heterogeneous, and dynamic computing environments where they can demonstrate their advantages in scenarios requiring efficient utilization of heterogeneous computing resources and optimized task scheduling. Some potential application scenarios include: scientific computing and simulation, IoT analytics, edge computing, and real-time stream processing. However, existing technologies cannot comprehensively manage global function resource status information to address issues such as platform load balancing, network congestion, and resource utilization. This means that higher-performance server-side seamless framework scheduling strategies may not be available, leading to performance bottlenecks. Furthermore, complex services require function composition, i.e., coordination between functions; centrally scheduling functions within the same region is inflexible and computationally expensive. Summary of the Invention

[0003] This invention aims to address at least one of the technical problems existing in the prior art. To this end, this invention proposes a function resource management method, system, device, and medium with a server-independent framework, which can improve the overall computing performance of the workflow while reducing the cost of function communication.

[0004] In a first aspect, embodiments of the present invention provide a function resource management method for a server-insensitive framework, the function resource management method for the server-insensitive framework comprising:

[0005] Obtain the function resource scheduling request, and separate the read request and write request based on the function resource scheduling request to obtain the separated read request and the separated write request;

[0006] The separated write request is sent to multiple on-demand function instances, which then process the separated write request.

[0007] Construct multiple constraints and select multiple bidding function instances that satisfy the multiple constraints;

[0008] The separated read requests are sent to multiple auction function instances, and the multiple auction function instances are used to process the separated read requests, so as to realize the function resource management of the server-insensitive framework.

[0009] Compared with the prior art, the first aspect of the present invention has the following beneficial effects:

[0010] This method obtains function resource scheduling requests, separates read and write requests based on these requests, and sends the separated write requests to multiple on-demand function instances. These instances then process the separated write requests. By separating read and write requests and using different function instances for processing, this provides a high-throughput read request workload for the later implementation of a server-independent framework for function resource management, and improves data fault tolerance. Multiple constraints are constructed, and multiple bidding function instances that satisfy these constraints are selected, enabling the scheduling of workloads to a set of functions with a fixed topology. Sending the separated read requests to multiple bidding function instances and using these instances to process them achieves server-independent framework function resource management. Bidding function instances can avoid performance degradation due to excessive load on a single function node while also considering computational costs. Therefore, sending the separated read requests to multiple bidding function instances ensures that the overall computational performance of the workflow is improved while reducing function communication costs.

[0011] According to some embodiments of the present invention, the construction of multiple constraints includes:

[0012] Construct the first constraint condition that satisfies common needs and has a fixed inter-function cooperation relationship;

[0013] Construct a second constraint that maximizes the parallelism of the target service while satisfying common needs;

[0014] Construct the third constraint with the highest cost-effectiveness.

[0015] According to some embodiments of the present invention, selecting multiple bidding function instances that satisfy multiple constraints includes:

[0016] Based on the aforementioned server-insensitive framework, a global function resource topology graph is constructed;

[0017] A sampling method is used to select a set of points from the global function resource topology graph that satisfy the first constraint condition and appear in the matching subgraph;

[0018] Centered on each point in the set of points, multiple matching subgraph instances are searched in parallel. The matching subgraph instances are used as bidding function instances that satisfy the second constraint condition to obtain the first bidding function instance set.

[0019] According to some embodiments of the present invention, selecting multiple bidding function instances that satisfy multiple constraints further includes:

[0020] Calculate the score for each bid function instance in the first set of bid function instances;

[0021] Based on the scores, multiple bidding function instances that satisfy the third constraint are selected from the first set of bidding function instances.

[0022] According to some embodiments of the present invention, the step of selecting a set of points in a matching subgraph satisfying the first constraint condition from the global function resource topology graph using a sampling method includes:

[0023] The sampling probability of each point is calculated based on the degree of each point in the global function resource topology graph and the number of edges in the global function resource topology graph;

[0024] The set of points in the matching subgraph that satisfy the first constraint condition is selected based on the sampling probability.

[0025] According to some embodiments of the present invention, the score of each bidding function instance in the first bidding function instance set is calculated in the following manner:

[0026]

[0027] Where, score represents the score of each bidding function instance, n represents the number of bidding function instances in the first bidding function instance set, l1, l2, and l3 represent coefficients, i represents the i-th bidding function instance, and c i φ represents the CPU capacity of the current auction function instance. i ρ represents the available memory for the current auction function instance. i ξ represents the average price of the current bidding function instance. i This represents the probability of canceling an instance of the bidding function.

[0028] According to some embodiments of the present invention, the processing of the separated write request by a plurality of the on-demand function instances includes:

[0029] The separated write requests are processed by multiple instances of the on-demand function using a chained replication technique.

[0030] Secondly, embodiments of the present invention also provide a server-insensitive framework function resource management system, the server-insensitive framework function resource management system comprising:

[0031] The request acquisition unit is used to acquire function resource scheduling requests, and separate read requests and write requests based on the function resource scheduling requests to obtain separated read requests and separated write requests;

[0032] A request processing unit is used to send the separated write request to multiple on-demand function instances, which then process the separated write request.

[0033] An instance selection unit is used to construct multiple constraints and select multiple bidding function instances that satisfy the multiple constraints.

[0034] The resource management unit is used to send the separated read requests to multiple auction function instances, and use the multiple auction function instances to process the separated read requests, so as to realize the function resource management of the server-insensitive framework.

[0035] Thirdly, embodiments of the present invention also provide a function resource management device for a server-independent framework, including at least one control processor and a memory for communicatively connecting to the at least one control processor; the memory stores instructions executable by the at least one control processor, the instructions being executed by the at least one control processor to enable the at least one control processor to execute a function resource management method for a server-independent framework as described above.

[0036] Fourthly, embodiments of the present invention also provide a computer-readable storage medium storing computer-executable instructions for causing a computer to execute a function resource management method for a server-independent framework as described above.

[0037] It is understood that the beneficial effects of the second to fourth aspects compared with the related technologies are the same as the beneficial effects of the first aspect compared with the related technologies. Please refer to the relevant description in the first aspect above, which will not be repeated here. Attached Figure Description

[0038] The above and / or additional aspects and advantages of the present invention will become apparent and readily understood from the description of the embodiments taken in conjunction with the following drawings, in which:

[0039] Figure 1 This is a flowchart of a function resource management method for a server-side seamless framework according to an embodiment of the present invention;

[0040] Figure 2 This is a schematic diagram of a Geo-function algorithm according to an embodiment of the present invention;

[0041] Figure 3 This is a schematic diagram of the algorithm 1 according to an embodiment of the present invention;

[0042] Figure 4 This is a schematic diagram of the algorithm 2 according to an embodiment of the present invention;

[0043] Figure 5 This is a schematic diagram of a practical application scenario of another embodiment of the present invention;

[0044] Figure 6This is a structural diagram of a server-insensitive framework function resource management system according to an embodiment of the present invention;

[0045] Figure 7 This is a schematic diagram of the structure of an electronic device according to an embodiment of the present invention. Detailed Implementation

[0046] Embodiments of the present invention are described in detail below. Examples of these embodiments are shown in the accompanying drawings, wherein the same or similar reference numerals denote the same or similar elements or elements having the same or similar functions throughout. The embodiments described below with reference to the accompanying drawings are exemplary and are only used to explain the present invention, and should not be construed as limiting the present invention.

[0047] In the description of this invention, the use of terms such as "first," "second," etc., is for the purpose of distinguishing technical features only and should not be construed as indicating or implying relative importance, or implicitly indicating the number of technical features indicated, or implicitly indicating the order of the technical features indicated.

[0048] In the description of this invention, it should be understood that the orientation descriptions, such as up, down, etc., are based on the orientation or positional relationship shown in the drawings and are only for the convenience of describing this invention and simplifying the description, and are not intended to indicate or imply that the device or element referred to must have a specific orientation, or be constructed and operated in a specific orientation, and therefore should not be construed as a limitation of this invention.

[0049] In the description of this invention, it should be noted that, unless otherwise explicitly defined, terms such as "setting," "installation," and "connection" should be interpreted broadly, and those skilled in the art can reasonably determine the specific meaning of the above terms in this invention in conjunction with the specific content of the technical solution.

[0050] First, let's analyze some of the terms used in this application:

[0051] Serverless computing is a cloud service computing paradigm characterized by fine-grained resource allocation and a high degree of abstraction. It is also known as serverless computing. This paradigm provides developers with on-demand, elastically scalable cloud services, hiding the operational details of servers and making them unaware of their existence.

[0052] Serverless Framework: The Serverless Framework is a platform for realizing server-side seamless computing. It provides a gateway to receive function workflows, manages and schedules function containers, and allows configuration of various function parameters. It is the optimization target of various technical points in this invention.

[0053] Function: A function is the basic unit of server-side seamless computing. It is responsible for encapsulating the developer's code and deploying it to the server-side seamless framework. Functions are managed and scheduled by the server-side seamless framework, and multiple functions can be combined to form a function workflow.

[0054] Topological representation is a method or model for describing the resource distribution and connectivity of function instances within a server-side, seamless computing framework. This representation focuses on revealing the topological structure between function instances to better understand and manage their collaborative relationships.

[0055] On-demand function instances: On-demand function instances are equivalent to on-demand instances with a service granularity of "function level," representing stable computing power in the cloud. It is one way cloud providers sell their computing power, characterized by stability and reliability, and priced higher than spot function instances.

[0056] Spot function instances: Spot function instances (preemptive function instances) are equivalent to preemptive instances with a service granularity of "function level," representing idle computing power in the cloud. It is one way cloud providers sell their computing power, characterized by low cost and the ability to be reclaimed at any time.

[0057] Existing server-side seamless frameworks for function composition scheduling mostly rely on brief information about the function's region to implement scheduling strategies. By centrally calling functions within the same region or by statically predefining functions at the code level, they improve data locality and reduce transmission latency, making them suitable for various application scenarios, especially in large-scale, heterogeneous, and dynamic computing environments where they can demonstrate their advantages in scenarios requiring efficient utilization of heterogeneous computing resources and optimized task scheduling. Some potential application scenarios include: scientific computing and simulation, IoT analytics, edge computing, and real-time stream processing. However, existing technologies cannot comprehensively manage global function resource status information to address issues such as platform load balancing, network congestion, and resource utilization. This means that higher-performance server-side seamless framework scheduling strategies may not be available, leading to performance bottlenecks. Furthermore, complex services require function composition, i.e., coordination between functions; centrally scheduling functions within the same region is inflexible and computationally expensive.

[0058] To address the aforementioned issues, this invention obtains function resource scheduling requests, separates read and write requests based on these requests, and sends the separated write requests to multiple on-demand function instances. These instances then process the separated write requests. By separating read and write requests and using different function instances for processing, this provides a high-throughput read request workload for the subsequent server-independent framework function resource management and improves data fault tolerance. Multiple constraints are constructed, and multiple bidding function instances that satisfy these constraints are selected, enabling the scheduling of workloads to a fixed-topology function set. Sending the separated read requests to multiple bidding function instances and using these instances to process them achieves server-independent framework function resource management. The bidding function instances can avoid performance degradation due to excessive load on a single function node while also considering computational costs. Therefore, sending the separated read requests to multiple bidding function instances ensures that the overall computational performance of the workflow is improved while reducing function communication costs.

[0059] Reference Figure 1 This invention provides a function resource management method for a server-insensitive framework. This method includes, but is not limited to, steps S100 to S400, wherein:

[0060] Step S100: Obtain the function resource scheduling request, and separate the read request and write request based on the function resource scheduling request to obtain the separated read request and the separated write request;

[0061] Step S200: Send the separated write requests to multiple on-demand function instances, which will then process the separated write requests.

[0062] Step S300: Construct multiple constraints and select multiple bidding function instances that satisfy the multiple constraints;

[0063] Step S400: Send the separated read requests to multiple auction function instances, and use multiple auction function instances to process the separated read requests, so as to realize the function resource management of the server-insensitive framework.

[0064] In this embodiment, to provide a high-throughput read request workload for the server-independent framework's function resource management and improve data fault tolerance, this embodiment obtains a function resource scheduling request, separates read and write requests based on the function resource scheduling request, and sends the separated read and write requests to multiple on-demand function instances for processing. To schedule the workload to a function set with a fixed topology, this embodiment constructs multiple constraints and selects multiple bidding function instances that satisfy these constraints. To ensure that the overall computational performance of the workflow is improved while reducing function communication costs, this embodiment sends the separated read requests to multiple bidding function instances for processing, thereby achieving server-independent framework function resource management.

[0065] In some embodiments, multiple constraints are constructed, including:

[0066] Construct the first constraint condition that satisfies common needs and has a fixed inter-function cooperation relationship;

[0067] Construct a second constraint that maximizes the parallelism of the target service while satisfying common needs;

[0068] Construct the third constraint with the highest cost-effectiveness.

[0069] In this embodiment, by constructing the first constraint, the second constraint, and the third constraint, the function resource management of the server-insensitive framework can meet common needs while having fixed inter-function collaboration relationships, maximum target service parallelism, and the highest cost-effectiveness.

[0070] In some embodiments, multiple bidding function instances that satisfy multiple constraints are selected, including:

[0071] Based on a server-insensitive framework, construct a global function resource topology graph;

[0072] A sampling method is used to select the set of points in the matching subgraph that satisfy the first constraint condition from the global function resource topology graph;

[0073] Centered on each point in the point set, multiple matching subgraph instances are searched in parallel. The matching subgraph instances are used as bidding function instances that satisfy the second constraint condition to obtain the first bidding function instance set.

[0074] In this embodiment, the scheduling of workloads to a set of functions with a fixed topology is achieved by solving the subgraph matching problem in the function resource topology.

[0075] In some embodiments, selecting multiple bidding function instances that satisfy multiple constraints further includes:

[0076] Calculate the score for each bid function instance in the first set of bid function instances;

[0077] Based on the scores, select multiple bidding function instances that satisfy the third constraint from the first set of bidding function instances.

[0078] In this embodiment, the score of each bidding function instance in the first bidding function instance set is calculated, and multiple bidding function instances with the highest cost performance are selected to process read requests based on the scores. This can reduce the resource usage and cost of the server-insensitive framework in a heterogeneous computing environment.

[0079] In some embodiments, a sampling method is used to select a set of points in a matching subgraph that satisfy the first constraint condition from the global function resource topology graph, including:

[0080] Calculate the sampling probability of each point based on the degree of each point in the global function resource topology graph and the number of edges in the global function resource topology graph;

[0081] The set of points in the matching subgraph that satisfy the first constraint condition is selected based on the sampling probability.

[0082] In this embodiment, by selecting the set of points that satisfy the first constraint condition and appear in the matching subgraph based on the sampling probability, it is possible to select points with a higher probability of appearing in the matching subgraph and form a set.

[0083] In some embodiments, the score for each bidding function instance in the first set of bidding function instances is calculated as follows:

[0084]

[0085] Where, score represents the score of each bidding function instance, n represents the number of bidding function instances in the first bidding function instance set, l1, l2, and l3 represent coefficients, i represents the i-th bidding function instance, and c i φ represents the CPU capacity of the current auction function instance. i ρ represents the available memory for the current auction function instance. i ξ represents the average price of the current bidding function instance. i This represents the probability of canceling an instance of the bidding function.

[0086] In some embodiments, the detached write requests are handled by multiple on-demand function instances, including:

[0087] Chained replication technology is used to handle the separated write requests by multiple on-demand function instances.

[0088] In this embodiment, chained replication technology is used to form a chain among multiple on-demand function instances. The separated write requests are sent sequentially to the chained on-demand function instances, which can support strong consistency between services.

[0089] To facilitate understanding by those skilled in the art, a set of preferred embodiments is provided below:

[0090] This embodiment addresses the high cost of functions in traditional solutions by comprehensively considering global function resource status information and balancing cost expenditure with function performance. Through a graph-based heterogeneous function resource representation, it abstracts the characteristics and network relationships of functions on a server-insensitive framework platform, reducing function communication costs while improving overall workflow computational performance. Furthermore, by solving the subgraph matching problem in the function resource topology, it enables the scheduling of workloads to a set of functions with a fixed topology. This embodiment specifically includes the following:

[0091] We construct a geo-distributed function composition scheduling method (i.e., Geo-function). Geo-function is a server-insensitive framework scheduling method oriented towards function composition, which can leverage geographically distributed function resources to support read-intensive workloads running on server-insensitive framework platforms.

[0092] Reference Figure 2This diagram illustrates the Geo-function algorithm, where the client submits its application to the cloud platform and sends a resource scheduling request. To support high-throughput read request workloads and ensure data fault tolerance, the system utilizes chain replication to create a chain of on-demand function instances. Read requests can be sent to any replica, while write requests are executed sequentially in a chain, ensuring data consistency. When a read request reaches a replica node, the node sends or offloads the read request to another spot function instance for execution. This process separates read and write requests within the application, sending them to different computation function instances for processing: read operations are sent to spot functions, and write operations are sent to on-demand functions. A master-slave architecture is formed between the two types of function instances. The on-demand function (master instance) synchronizes write operations to the spot function (slave instance), and the slave instance returns the latest data to the client. To achieve load balancing across computational instances of read requests, read requests are distributed to multiple sets of functions with fixed topologies (e.g., k-star, k-pizza). This avoids performance degradation due to excessive load on a single function node. The use of spot functions can balance computational cost. Based on this method, real-time topology representation of complex functions can be achieved.

[0093] Based on the geographically distributed function combinatorial scheduling method, a function resource management method for server-insensitive computing frameworks can be further implemented to construct a function resource management system based on topology representation. The overall task scheduling process of the system described above can be summarized into the following steps:

[0094] Step 1: Geo-function separates read and write operations for services when a new service request arrives.

[0095] Step 2: Write operations are handled by multiple on-demand function instances using chained copying technology.

[0096] Step 3: Read requests are dispatched from the on-demand function instance (primary instance) to the auction function instance (secondary instance).

[0097] In Step 3, Geo-function runs a monitoring process to monitor resource requirements, instance statistics, and workload profiles. If the target service exceeds the default workload limit of a single function node, this embodiment aims to lease multiple bid function instances that collaborate to jointly complete the read operation service. Therefore, the following constraints need to be met:

[0098] 1. Select multiple function instances to form a fixed topology (with fixed inter-function collaboration relationships) to jointly meet the requirements; 2. Select a set of k function instances (based on the maximum parallelism of the target service) to meet the requirements; 3. Select the top k function instance sets with the highest cost-effectiveness online. Considering that most actual cluster operations follow a master-slave model, this embodiment will focus on finding k-star and k-pizza patterns to offload read operations.

[0099] The main problem to be solved next is which set of function instances should be purchased for a given read-intensive data service. (Refer to...) Figure 3 The flowchart of Algorithm 1 is shown. Algorithm 1 can quickly calculate the set of function instances that satisfy a fixed topology and meet the maximum parallelism of the target service. Specifically, Algorithm 1 is as follows:

[0100] On the global function resource topology graph, sampling techniques are used to select points with a high probability of forming a matching subgraph and form a set. Starting from this set, parallel searches are conducted for matching subgraph instances within a radius d. Specifically:

[0101] 1. In the algorithm, Line 3 states that each point is assigned a different sampling probability, calculated as: p = dv1 / 2m, where dv1 represents the degree of point v1, and m represents the total number of edges in the global function resource topology graph. This shows that the probability of a point being sampled is fundamentally related to its degree. The higher the degree of a node, the greater the likelihood of finding a matching subgraph pattern near that point.

[0102] 2. Lines 6 to 8 of the algorithm state: In the point set collected in the previous step, it is known that each point has a considerable probability of retrieving a matching subgraph instance in its vicinity. Therefore, by considering multiple threads, each thread searches for matching subgraph instances with a radius d as the search center, and adds them sequentially to the SI set.

[0103] Due to the highly dynamic nature of cloud server platforms, the global function resource topology is constantly changing. This algorithm will be repeatedly executed at intervals to meet the real-time scheduling needs of users.

[0104] Reference Figure 4 The flowchart for Algorithm 2 illustrates how it uses the approximate algorithm MCSA to select the top-k most cost-effective subgraph instances, calculating the k most efficient subgraph instances (the set of computational function instances). The spot function is determined based on the current function node's CPU capacity (c) and available memory. The average price ρ and the spot function withdrawal probability ξ are quantified using the following weighted formula, in addition, l iThese represent their coefficients. The revocation probability can be predicted using the RevPred model. Therefore, the scoring formula for subgraph instances can be derived, which is the sum of the scores of the n spot function instances in the set:

[0105]

[0106] Algorithm 2 specifically includes:

[0107] Algorithm 1 yields a series of subgraph instances (representing a set of functions) that satisfy the topological requirements. Assuming k is the number of subgraph instances to be rented (related to the parallelism of the task), the score for each subgraph instance in the set can be derived from the equation above. The top-k subgraph instances can be selected using the MCSA algorithm (Multiple-Choice Secretary Algorithm, i.e., Algorithm 2).

[0108] 1. The input to the MCSA algorithm is a subgraph instance score array `score[]` and the required number of subgraph instances `k`, where `R` is `len(score[])`, i.e., the total number of subgraph instances. The output is an array `topk[]` storing the indices of the selected `k` subgraph instances. Here, `len` is the length calculation function.

[0109] 2. In the algorithm, for lines 3 to 7, if k > 1, the search space is divided into two groups: floor(k / 2) indices are found in [L, L+m-1], and k-floor(k / 2) indices are found in [L+m, R]. Here, L represents a constant 1, m represents a random number following a binomial distribution, and floor represents the floor function.

[0110] 3. In lines 8 to 26 of the algorithm, if k = 1, the algorithm first finds the largest mx number in the range [L, L+n-1]. Then, it sequentially finds a number larger than mx in the range [L+n, R] and stores it in the topk array. If no such number is found, mx is stored in the topk array. Here, n is the floor of len / e, representing the number of all subgraph instances divided by e and rounded up. mx is used to store the score of the largest subgraph instance found in the range [1,n]. val is used to store the score of the current subgraph instance.

[0111] 4. The algorithm is executed repeatedly until k=1 and an index number is obtained.

[0112] In this embodiment, supporting read-intensive data services is crucial in a server-independent computing environment. Maintaining strong consistency while supporting such read-intensive data services across geographically diverse sites is both expensive and complex. To address these issues, Geo-function, a function scheduling framework for server-independent platforms, is proposed. It offloads task read operations to spot functions and sequentially sends write requests to a chain-replicated function, serving as a solution to support strong consistency between services. Furthermore, this embodiment designs a graph-based global function resource management system to perform real-time mapping from tasks to a fixed-topology function set.

[0113] To better illustrate this embodiment, the following is an example of a specific application scenario:

[0114] The above embodiments construct a heterogeneous function resource representation based on a graph model. This graph model aims to improve the abstraction of function characteristics and their network relationships on a server-insensitive framework platform, thereby reducing function communication costs and improving the overall computational performance of the workflow. Furthermore, by solving the subgraph matching problem in the function resource topology, it enables the scheduling of workloads to function sets with fixed topologies.

[0115] The proposed method has broad applicability and can be used in a variety of application scenarios, especially in large-scale, heterogeneous, and dynamic computing environments, where it can demonstrate its advantages in scenarios requiring efficient utilization of heterogeneous computing resources and optimized task scheduling. Some potential application scenarios include: scientific computing and simulation, IoT analytics, edge computing, and real-time stream processing.

[0116] Reference Figure 5 The server-insensitive framework platform (hereinafter referred to as the platform) designed in this embodiment is well-suited for scheduling heterogeneous computing resources in complex workflows. An example of scientific computing applications within the server-insensitive framework platform is presented and analyzed. Specifically:

[0117] Suppose we need to perform a large-scale data processing and workflow analysis. This workflow includes multiple tasks involving data extraction, transformation, loading (ETL), machine learning model training, and other stages. These tasks have varying computational requirements; some require significant CPU computation, some require GPU acceleration, and others may require specialized hardware (such as an FPGA).

[0118] The platform first uses a graph model to represent and abstract the node and network states of various machines (or computational functions), including CPU capacity, memory capacity, hardware performance, and inter-node communication costs. This allows the platform to globally monitor the state changes of all computing resources in the cluster and gain a deeper understanding of the computational characteristics and tendencies of each computational function. On the other hand, it analyzes the finer-grained operators within the task, examining their computational requirements, data input / output characteristics, applicable hardware types, data dependencies, and calling relationships between operators. This helps optimize operator partitioning and the communication costs between the corresponding computational functions, thereby improving overall computational performance. If we divide the scientific workflow into four stages—data extraction, data transformation, data loading, and machine learning training—each stage can be considered an operator. The platform will consider the computational resource requirements of different operators and select appropriate computational functions (i.e., on-demand function instances or auction function instances).

[0119] Data extraction and loading operators are typically I / O-intensive operations, requiring significant memory and fast storage access. Therefore, computational functions with high-speed disk and memory capabilities should be selected. Data transformation and machine learning model training operators involve computationally intensive operations such as data cleaning and format conversion, necessitating computational functions with strong computing power. Consideration should be given to using multi-core CPUs or dedicated hardware to improve performance. The computational load of a single operator may not be borne by a single computational function. To address this, operators are scheduled to run on a set of cooperating computational functions by solving the subgraph matching problem in the function resource topology, ensuring high computational efficiency and low overhead. Furthermore, the platform can dynamically adjust task allocation and scheduling, making intelligent decisions based on real-time resource conditions, task priorities, and hardware performance. This allows the system to maintain high efficiency under varying load conditions. Simultaneously, the platform needs to provide real-time monitoring capabilities to track task execution, resource utilization, and communication performance. Based on monitoring data, the system can implement further optimization strategies to adapt to changing workloads and hardware conditions.

[0120] With this design, the platform can manage and schedule various tasks more intelligently and efficiently in heterogeneous computing environments, thereby improving overall computing performance and resource utilization.

[0121] Reference Figure 6 This invention also provides a server-independent framework function resource management system, which includes a request acquisition unit 100, a request processing unit 200, an instance selection unit 300, and a resource management unit 400, wherein:

[0122] The request acquisition unit 100 is used to acquire function resource scheduling requests, and separate read requests and write requests based on function resource scheduling requests to obtain separated read requests and separated write requests;

[0123] The request processing unit 200 is used to send the separated write request to multiple on-demand function instances, which then process the separated write request.

[0124] Instance selection unit 300 is used to construct multiple constraints and select multiple bidding function instances that satisfy the multiple constraints;

[0125] Resource management unit 400 is used to send the separated read requests to multiple auction function instances, and use multiple auction function instances to process the separated read requests, so as to realize the function resource management of the server-insensitive framework.

[0126] It should be noted that since the function resource management system of the server-insensitive framework in this embodiment is based on the same inventive concept as the function resource management method of the server-insensitive framework described above, the corresponding content in the method embodiment is also applicable to this system embodiment, and will not be described in detail here.

[0127] Reference Figure 7 This application also provides a function resource management device for a server-insensitive framework, which includes:

[0128] At least one memory;

[0129] At least one processor;

[0130] At least one program;

[0131] The program is stored in memory, and the processor executes at least one program to implement the function resource management method of the server-insensitive framework described above in this disclosure.

[0132] This electronic device can be any smart terminal, including mobile phones, tablets, personal digital assistants (PDAs), and in-vehicle computers.

[0133] The electronic devices according to embodiments of this application will now be described in detail.

[0134] The processor 1600 can be implemented using a general-purpose central processing unit (CPU), microprocessor, application-specific integrated circuit (ASIC), or one or more integrated circuits, and is used to execute relevant programs to implement the technical solutions provided in the embodiments of this disclosure.

[0135] The memory 1700 can be implemented as a read-only memory (ROM), static storage device, dynamic storage device, or random access memory (RAM). The memory 1700 can store the operating system and other applications. When the technical solutions provided in the embodiments of this specification are implemented through software or firmware, the relevant program code is stored in the memory 1700 and is called and executed by the processor 1600 to execute the function resource management method of the server-side seamless framework of the embodiments of this disclosure.

[0136] The input / output interface 1800 is used to implement information input and output.

[0137] The communication interface 1900 is used to enable communication and interaction between this device and other devices. Communication can be achieved through wired means (such as USB, Ethernet cable, etc.) or wireless means (such as mobile network, WIFI, Bluetooth, etc.).

[0138] Bus 2000 transmits information between various components of the device (e.g., processor 1600, memory 1700, input / output interface 1800, and communication interface 1900);

[0139] The processor 1600, memory 1700, input / output interface 1800 and communication interface 1900 are connected to each other within the device via bus 2000.

[0140] This disclosure also provides a storage medium, which is a computer-readable storage medium storing computer-executable instructions for causing a computer to execute the function resource management method of the aforementioned server-insensitive framework.

[0141] Memory, as a non-transitory computer-readable storage medium, can be used to store non-transitory software programs and non-transitory computer-executable programs. Furthermore, memory may include high-speed random access memory, and may also include non-transitory memory, such as at least one disk storage device, flash memory device, or other non-transitory solid-state storage device. In some embodiments, memory may optionally include memory remotely located relative to the processor, and these remote memories can be connected to the processor via a network. Examples of such networks include, but are not limited to, the Internet, intranets, local area networks, mobile communication networks, and combinations thereof.

[0142] The embodiments described in this disclosure are for the purpose of more clearly illustrating the technical solutions of this disclosure and do not constitute a limitation on the technical solutions provided by this disclosure. As those skilled in the art will know, with the evolution of technology and the emergence of new application scenarios, the technical solutions provided by this disclosure are also applicable to similar technical problems.

[0143] Those skilled in the art will understand that the technical solutions shown in the figures do not constitute a limitation on the embodiments of this disclosure, and may include more or fewer steps than shown, or combine certain steps, or different steps.

[0144] The device embodiments described above are merely illustrative. The units described as separate components may or may not be physically separate; that is, they may be located in one place or distributed across multiple network units. Some or all of the modules can be selected to achieve the purpose of this embodiment according to actual needs.

[0145] Those skilled in the art will understand that all or some of the steps in the methods disclosed above, as well as the functional modules / units in the systems and devices, can be implemented as software, firmware, hardware, or suitable combinations thereof.

[0146] The terms “first,” “second,” “third,” “fourth,” etc. (if present) in the specification and accompanying drawings of this application are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that the embodiments of this application described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms “comprising” and “having,” and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, system, product, or apparatus that comprises a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or apparatus.

[0147] It should be understood that in this application, "at least one (item)" means one or more, and "more than" means two or more. "And / or" is used to describe the relationship between related objects, indicating that three relationships can exist. For example, "A and / or B" can represent three cases: only A exists, only B exists, and both A and B exist simultaneously, where A and B can be singular or plural. The character " / " generally indicates that the preceding and following related objects are in an "or" relationship. "At least one (item) of the following" or similar expressions refer to any combination of these items, including any combination of single or plural items. For example, at least one (item) of a, b, or c can represent: a, b, c, "a and b", "a and c", "b and c", or "a and b and c", where a, b, and c can be single or multiple.

[0148] In the several embodiments provided in this application, it should be understood that the disclosed apparatus and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be through some interfaces; the indirect coupling or communication connection between apparatuses or units may be electrical, mechanical, or other forms.

[0149] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0150] Furthermore, the functional units in the various embodiments of this application can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0151] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this application, in essence, or the part that contributes to the prior art, or all or part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes multiple instructions to cause an electronic device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of the various embodiments of this application. The aforementioned storage medium includes various media capable of storing programs, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks. The embodiments of this application have been described in detail above with reference to the accompanying drawings, but this application is not limited to the above embodiments. Various changes can be made within the scope of knowledge possessed by those skilled in the art without departing from the spirit of this application.

Claims

1. A method for function resource management within a server-side, seamless framework, characterized in that: The function resource management method of the server-insensitive framework includes: Obtain the function resource scheduling request, and separate the read request and write request based on the function resource scheduling request to obtain the separated read request and the separated write request; The separated write request is sent to multiple on-demand function instances, which then process the separated write request, including: The separated write requests are processed by multiple instances of the on-demand function using chained replication technology. Construct multiple constraints and select multiple bidding function instances that satisfy the multiple constraints, including: Construct the first constraint condition that satisfies common needs and has a fixed inter-function cooperation relationship; Construct a second constraint that maximizes the parallelism of the target service while satisfying common needs; Construct the third constraint with the highest cost-effectiveness; Based on the aforementioned server-insensitive framework, a global function resource topology graph is constructed; A sampling method is used to select a set of points from the global function resource topology graph that satisfy the first constraint condition and appear in the matching subgraph; Centered on each point in the point set, multiple matching subgraph instances are searched in parallel. The matching subgraph instances are used as bidding function instances that satisfy the second constraint condition to obtain the first bidding function instance set. The separated read requests are sent to multiple auction function instances, and the multiple auction function instances are used to process the separated read requests, so as to realize the function resource management of the server-insensitive framework.

2. The function resource management method of the server-insensitive framework according to claim 1, characterized in that, The step of selecting multiple bidding function instances that satisfy multiple constraints further includes: Calculate the score for each bid function instance in the first set of bid function instances; Based on the scores, multiple bidding function instances that satisfy the third constraint are selected from the first set of bidding function instances.

3. The function resource management method of the server-insensitive framework according to claim 1, characterized in that, The step of selecting a set of points from the global function resource topology graph that satisfy the first constraint condition and appear in a matching subgraph using a sampling method includes: The sampling probability of each point is calculated based on the degree of each point in the global function resource topology graph and the number of edges in the global function resource topology graph; The set of points in the matching subgraph that satisfy the first constraint condition is selected based on the sampling probability.

4. The function resource management method of the server-insensitive framework according to claim 2, characterized in that, The score for each bidding function instance in the first set of bidding function instances is calculated as follows: ； in, This represents the score for each instance of the bidding function. This indicates the number of auction function instances in the first auction function instance set. , and Represents the coefficient. Indicates the first An example of a bidding function This indicates the CPU capacity of the current auction function instance. This indicates the available memory for the current auction function instance. This represents the average price of the current auction function instance. This represents the probability of canceling an instance of the bidding function.

5. A server-insensitive framework-based function resource management system, characterized in that, The server-insensitive framework's function resource management system includes: The request acquisition unit is used to acquire function resource scheduling requests, and separate read requests and write requests based on the function resource scheduling requests to obtain separated read requests and separated write requests; A request processing unit is configured to send the separated write request to multiple on-demand function instances, wherein the multiple on-demand function instances process the separated write request, including: The separated write requests are processed by multiple instances of the on-demand function using chained replication technology. An instance selection unit is used to construct multiple constraints and select multiple bidding function instances that satisfy the multiple constraints, including: Construct the first constraint condition that satisfies common needs and has a fixed inter-function cooperation relationship; Construct a second constraint that maximizes the parallelism of the target service while satisfying common needs; Construct the third constraint with the highest cost-effectiveness; Based on the aforementioned server-insensitive framework, a global function resource topology graph is constructed; A sampling method is used to select a set of points from the global function resource topology graph that satisfy the first constraint condition and appear in the matching subgraph; Centered on each point in the point set, multiple matching subgraph instances are searched in parallel. The matching subgraph instances are used as bidding function instances that satisfy the second constraint condition to obtain the first bidding function instance set. The resource management unit is used to send the separated read requests to multiple auction function instances, and use the multiple auction function instances to process the separated read requests, so as to realize the function resource management of the server-insensitive framework.

6. A server-insensitive framework function resource management device, characterized in that, It includes at least one control processor and a memory for communicatively connecting to the at least one control processor; the memory stores instructions executable by the at least one control processor, which, when executed by the at least one control processor, enable the at least one control processor to perform the function resource management method of the server-insensitive framework as described in any one of claims 1 to 4.

7. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions for causing a computer to perform the function resource management method of the server-insensitive framework as described in any one of claims 1 to 4.

Images