Zygote container-based service fast start method and system in serverless edge cloud

Abstract

The present application relates to the field of edge cloud, more particularly, to a method and system for fast starting of Zygote container-based service in serverless edge cloud, wherein the method comprises: obtaining a function set to be invoked and function dependency package information of all functions in the function set; obtaining a frequent item set set composed of all frequent item sets; performing descending order sorting on the frequent item set set; generating a Zygote container; judging whether each function in the function set to be invoked can be started through the Zygote; if yes, starting the function through the Zygote; if not, starting the function through cold start. The present application performs descending order sorting on the frequent item set set, and finally generates a Zygote container according to the sorted frequent item set set; the Zygote container generated through the method is relatively simple and can be started quickly by as many function applications as possible, thereby improving the starting efficiency.

Description

TECHNICAL FIELD

[0001] The present application relates to the field of edge cloud, more particularly, to a method and system for fast service startup based on Zygote container in serverless edge cloud. BACKGROUND

[0002] Edge cloud takes advantage of its ubiquity, high network bandwidth and low network latency to provide fast response services for users. Serverless computing, as a new Function-as-a-Service (FaaS) computing paradigm, can achieve fine-grained resource allocation and high scalability by decomposing complex monolithic applications into many small computing units that become functions supported by container technology. Although designed for central cloud, due to its great potential in easy scalability and efficient management, extending serverless computing to edge has been considered as a potentially promising way to help the development of edge computing. Therefore, serverless edge cloud has attracted widespread attention. In serverless computing, a function can be started when it is called and ended when it is no longer needed to save resources. However, starting a containerized function requires many initialization operations, which raises the problem of cold start of the function. Recently, it has been found that full container preloading consumes memory and Zygote container has been proposed, which imports some common packages in advance. When a function is called, if its corresponding container can use the preloaded Zygote, it can fork a new container based on the Zygote and import other dependent packages that the function needs but are not in the Zygote. Since the function only needs to spend a little time to import dependent packages into the forked container in this case, compared with its cold start time, this method can achieve faster startup of the function. At the same time, since different functions may have common dependent packages, Zygote can be used as a "parent container" for different functions, that is, different functions can use the same Zygote container under certain conditions (for example, the preloaded packages in the Zygote must be a subset of the function dependent packages). In this way, it can significantly improve the efficiency of memory use and alleviate the cold start problem of function invocation. Due to the exclusivity of the function using the Zygote and the only addition property of the dependent packages in the container, however, a Zygote can only be hot-started by one function application, which affects the startup efficiency.

[0003] The prior art discloses an efficient Zygote container planning method and system for edge cloud service function startup, relates to the field of Zygote container planning, S1: constructing an edge cloud system, and setting a constraint relationship according to the edge cloud system; S2: constructing a minimized function startup time expression through the edge cloud system and the constraint relationship; S3: obtaining an approximate optimal feasible solution of the minimized function startup time expression through an RR algorithm; and S4: obtaining an allocation strategy of a Zygote container in the edge cloud system through the approximate optimal feasible solution. However, the method is relatively complicated to implement, and thus affects the startup efficiency. SUMMARY

[0004] The present application aims to disclose a Zygote container-based service fast startup method and system in a serverless edge cloud, which is simple to implement and has faster startup efficiency.

[0005] To achieve the above-mentioned purpose, the present application provides a Zygote container-based service fast startup method and system in a serverless edge cloud, which comprises the following steps:

[0006] S1: obtaining a function set to be called and function dependency package information of all functions in the function set; wherein the function set to be called comprises a plurality of functions;

[0007] S2: obtaining a frequent item set set composed of all dependency package frequent item sets according to the function dependency package information of all functions;

[0008] S3: performing descending order sorting on the frequent item set set to obtain a sorted frequent item set set;

[0009] S4: generating a Zygote container according to the sorted frequent item set set;

[0010] S5: judging whether each function in the function set to be called can be started through Zygote; if yes, starting the function through Zygote; if not, starting the function through cold startup.

[0011] Further, in step S1, the function set comprises dependency package basic information of all functions and cold startup time of each function; each dependency package basic information comprises the size of the dependency package and the introduction time of the dependency package.

[0012] The function set to be called is F, the set of function dependency packages of all functions in the function set is P, and the memory size of the server is M.

[0013] β fp ∈{0,1} represents whether a function f∈F needs a dependency package p∈P, β fp =1 means that it is needed, and β fp =0 means that it is not needed, and f=fp1 ,β fp2 ,…,β fp|P| >, the cold start time of function f∈F is τ f , according to the various β of function f fp Take the value and get the dependency package required by function f as {p i ,p j ,…,p k}; Define a dependency package p∈P with a size of S p , whose calling time is τ p , get the dependent package p= p ,τ p >∈P.

[0014] Furthermore, in step S2, it includes: according to the function dependency package information of all functions, using the FP-growth algorithm, when the minimum support is 1, all frequent item sets are obtained, and the pattern of the frequent item set is δ={p′ i ,p′ j ,…,p′ k :count}∈I, where p′ i ,p′ j ,…,p′ k ∈P, P is the set of function dependency packages of all functions in the function set, count is the frequency of occurrence of the frequent item set, and I represents the set of all frequent item sets.

[0015] Furthermore, in step S3, it includes: sorting each frequent item set in the frequent item set in descending order according to the frequency of occurrence. If the number of occurrences of several frequent item sets is the same, then these frequent item sets are sorted in descending order according to the total memory size occupied by the dependent packages in each frequent item set to obtain the final sorting result; specifically, all frequent item sets {δ1,δ2,…,δ |I|}, sort by the descending order of the frequency count of each δ∈I; if some of the frequent item sets in the frequent item set {δ i ,δ j ,…,δ k} have the same frequency of occurrence, then the total memory occupied by all dependent packages of each frequent item set δ in the frequent item set with the same frequency is S=∑ p∈δ S P , sort them in descending order to get the sorted frequent item set.

[0016] Furthermore, in step S4, it includes:

[0017] S4.1: Select the most frequently ordered item set δ∈I according to the sorted frequent item set set; ​

[0018] S4.2: Determine whether the total memory size S occupied by the most frequent itemset exceeds the memory size M allocated by the server for generating Zygote; if it exceeds, remove the currently selected most frequent itemset from the sorted frequent itemset set, and return to step S4.1 after the removal is completed; if S≤M, generate Zygote based on the most frequent itemset.

[0019] Furthermore, in step S4.1, it includes: selecting the most frequently ordered frequent item set δ∈I according to the sorted frequent item set set, where the most frequently ordered frequent item set δ∈I means that in the sorted frequent item set set, the frequent item set has the largest occurrence frequency count, and among several frequent item sets with the same occurrence frequency count, the total memory size S occupied by all dependent packages of the frequent item set is the largest in these frequent item sets.

[0020] Furthermore, in step S4.2, the total memory occupied size S of the dependent packages of the frequent item set δ is expressed as follows: S=∑ p∈δ S p ; Start comparing the total memory size S with the memory size M allocated by the server: if S>M, remove the currently selected frequent item set δ from the current frequent item set set I, the expression is I=I-δ, after the removal is completed, return to step S4; if S≤M, generate a Zygote based on the most frequent item set;

[0021] Generating Zygote according to the most frequent item set includes: for each dependent package p∈δ of the most frequent item set, p Set to 1.

[0022] Furthermore, in step S5, it includes: for function f∈F, if there exists β fp ∈f, where p∈P, which corresponds to α in the Zygote in the server p ,have (i.e. β fp =0 and α p =1), then γ f Set to 0, indicating that the function f cannot use the Zygote in the server; otherwise, γ f Set to 1, indicating that the function f can use the Zygote in the server.

[0023] Furthermore, in step S5, it also includes: calculating the startup time of each function in the function set and calculating the total startup time, which is specifically performed as follows: for each function f∈F of the function set F called by the current server, if γ f= 1, the function f can use the Zygote z of the server, the function f only needs to call the dependent package required by the function f but not contained in the Zygote, and the calling package time of the function f in F is t w (f) = ∑ p∈P γ f β fp (1-α p )τ p ; otherwise, γ f = 0, the function f cannot use the Zygote z of the server, the function f can only be cold started, and the cold start time of the function f is t c (f) = (1-γ f )τ f ; the start time of the function f in F is t s (f) = t c (f) + t w (f); finally, the total service start time T = ∑ f∈F t s (f) of all function start times in the function set F is calculated.

[0024] In addition, the application also provides a Zygote container-based service fast start system in a serverless edge cloud, comprising:

[0025] An acquisition module is configured to acquire a function set to be called and function dependent package information of all functions in the function set; wherein the function set to be called comprises a plurality of functions;

[0026] A set module is configured to obtain a frequent item set set comprising all dependent package frequent item sets according to the function dependent package information of all functions;

[0027] An ordering module is configured to perform descending order sorting on the frequent item set set to obtain a sorted frequent item set set;

[0028] A Zygote container module is configured to generate a Zygote container according to the sorted frequent item set set;

[0029] A start module is configured to judge whether each function in the function set to be called can be started through the Zygote; if yes, the function is started through the Zygote; if not, the function is started through cold start.

[0030] Compared with the prior art, the technical scheme of the application has the beneficial effects that:

[0031] The application obtains a frequent item set set composed of all dependent package frequent item sets according to the function dependent package information of all functions; then sorts the frequent item set set in descending order to obtain a sorted frequent item set set; and finally generates a Zygote container according to the sorted frequent item set set. The method for generating the Zygote container is relatively simple and can make the generated Zygote container be quickly started by as many function applications as possible, thereby improving the starting efficiency. BRIEF DESCRIPTION OF DRAWINGS

[0032] Figure 1 The serverless edge cloud-based service quick starting method flowchart based on the Zygote container is described in Embodiment One;

[0033] Figure 2 The serverless edge cloud-based service quick starting system block diagram based on the Zygote container is described in Embodiment Three; DETAILED DESCRIPTION

[0034] The accompanying drawings are only used for illustrative purposes and cannot be understood as a limitation on the patent;

[0035] The technical solutions of the application will be further described below in combination with the drawings and embodiments.

[0036] Embodiment One:

[0037] The embodiment provides a serverless edge cloud-based service quick starting method based on a Zygote container as shown in Figure 1 The serverless edge cloud-based service quick starting method based on the Zygote container comprises the following steps:

[0038] S1: acquiring a function set to be called and function dependent package information of all functions in the function set; wherein the function set to be called comprises a plurality of functions;

[0039] S2: obtaining a frequent item set set composed of all dependent package frequent item sets according to the function dependent package information of all functions;

[0040] S3: sorting the frequent item set set in descending order to obtain a sorted frequent item set set;

[0041] S4: generating a Zygote container according to the sorted frequent item set set;

[0042] S5: judging whether each function in the function set to be called can be started through the Zygote; if yes, starting the function through the Zygote; if not, starting the function through a cold start.

[0043] The embodiment obtains a frequent item set set composed of all dependent package frequent item sets according to function dependency package information of all functions; then sorts the frequent item set set in descending order to obtain a sorted frequent item set set; and finally generates a Zygote container according to the sorted frequent item set set. The method for generating the Zygote container is relatively simple, and the generated Zygote container can be quickly started by as many function applications as possible, thereby improving the starting efficiency.

[0044] Embodiment two:

[0045] The embodiment is further disclosed on the basis of the embodiment one:

[0046] In step S1, the function set includes dependent package basic information of all functions and cold start time of each function; each dependent package basic information includes size of the dependent package and introduction time of the dependent package;

[0047] The function set to be called is F, the function dependency package set of all functions in the function set is P, and the memory size of the server is M;

[0048] β fp ∈{0,1} represents whether the function f∈F needs the dependent package p∈P, β fp =1 needs, and β fp =0 does not need, f= <β fp1 ,β fp2 ,…,β fp|P| >, the cold start time of the function f∈F is τ f , according to the value of each β fp of the function f, the dependent package needed by the function f is {p i ,p j ,…,p k}; the size of a dependent package p∈P is defined as S p , the call time is τ p , and the dependent package p= <S p ,τ p >∈P is obtained.

[0049] In step S2, the following is included: according to function dependency package information of all functions, using the FP-growth algorithm, all frequent item sets are obtained under the condition that the minimum support is 1, and the mode of the frequent item set is δ= {p′ i ,p′ j ,…,p′ k :conut}∈I, wherein p′ i ,p′ j ,…,p′ k∈P, P is the function dependency package set of all functions in the function set, count is the appearance frequency of the frequent item set, and I represents a set composed of all frequent item sets.

[0050] In step S3, each frequent item set in the frequent item set set is sorted in descending order of appearance frequency, and if the appearance frequencies of several frequent item sets are the same, the several frequent item sets are sorted in descending order of the total memory size occupied by the dependency packages in each frequent item set, to obtain a final sorting result. Specifically, all frequent item sets {δ1, δ2,..., δn} in the frequent item set are sorted in descending order of the appearance frequency of each δ∈I. If the appearance frequencies of several frequent item sets {δ1, δ2,..., δn} in the frequent item set set are the same, the several frequent item sets are sorted in descending order of the total memory size S = ∑ |I| S i of all dependency packages in each frequent item set δ with the same frequency, to obtain a sorted frequent item set set. j k p∈δ p

[0051] In step S4, the following is included.

[0052] S4.1: selecting a most front frequent item set δ∈I from the sorted frequent item set set;

[0053] S4.2: judging whether the total memory size S of the most front frequent item set exceeds the memory size M allocated by a server for generating a Zygote; if yes, removing the currently selected most front frequent item set from the sorted frequent item set set, and returning to step S4.1 after the removal; if no, generating the Zygote according to the most front frequent item set.

[0054] In step S4.1, the most front frequent item set δ∈I is selected from the sorted frequent item set set. The most front frequent item set δ∈I means that the appearance frequency count of the frequent item set is the largest in the sorted frequent item set set, and the total memory size S of all dependency packages of the frequent item set is the largest among several frequent item sets with the same appearance frequency count.

[0055] In step S4.2, the expression of the total memory size S of the dependency packages of the frequent item set δ is S = ∑ p∈δ S p ​​​​; Start comparing the total memory size S with the memory size M allocated by the server: if S>M, remove the currently selected frequent item set δ from the current frequent item set set I, the expression is I=I-δ, after the removal is completed, return to step S4; if S≤M, generate a Zygote based on the most frequent item set;

[0056] Generating Zygote according to the most frequent item set includes: for each dependent package p∈δ of the most frequent item set, p Set to 1.

[0057] In step S5, it includes: for function f∈F, if there exists β fp ∈f, where p∈P, which corresponds to α in the Zygote in the server p ,have (i.e. β fp =0 and α p =1), then γ f Set to 0, indicating that the function f cannot use the Zygote in the server; otherwise, γ f Set to 1, indicating that the function f can use the Zygote in the server.

[0058] In step S5, it also includes: calculating the startup time of each function in the function set and calculating the total startup time, which is specifically performed as follows: for each function f∈F of the function set F called by the current server, if γ f =1, then the function f can use the server's Zygotez. Function f only needs to call the dependent packages that the function needs but are not included in Zygote. The calling time of function f∈F is t w (f)=∑ p∈P γ f β fp (1-α p )τ p Otherwise, γ f = 0, then the function f cannot use the server's Zygotez, and the function f can only be cold-started. The cold-start time of the function f is t c (f) = (1-γ f )τ f ; The startup time of function f∈F is t s (f) = t c (f)+t w (f); Finally, calculate the total service startup time T composed of the startup time of all functions in the function set F = ∑ f∈F t s (f).

[0059] The embodiment obtains a frequent item set set composed of all dependent package frequent item sets according to function dependent package information of all functions; then sorts the frequent item set set in descending order to obtain a sorted frequent item set set; and finally generates a Zygote container according to the sorted frequent item set set. The Zygote container is generated by the method more easily and can be started quickly by as many function applications as possible, thereby improving the starting efficiency.

[0060] Embodiment three

[0061] The embodiment also provides a serverless edge cloud service quick starting system based on a Zygote container, as shown in the accompanying drawings. Figure 2 The serverless edge cloud service quick starting system based on the Zygote container comprises:

[0062] The obtaining module obtains a function set to be called and function dependent package information of all functions in the function set; wherein the function set to be called comprises a plurality of functions.

[0063] The set module obtains a frequent item set set composed of all dependent package frequent item sets according to the function dependent package information of all functions.

[0064] The sorting module sorts the frequent item set set in descending order to obtain a sorted frequent item set set.

[0065] The Zygote container module generates a Zygote container according to the sorted frequent item set set.

[0066] The starting module judges whether each function in the function set to be called can be started through the Zygote; if yes, the function is started through the Zygote; if not, the function is started through a cold start.

[0067] The embodiment obtains a frequent item set set composed of all dependent package frequent item sets according to function dependent package information of all functions; then sorts the frequent item set set in descending order to obtain a sorted frequent item set set; and finally generates a Zygote container according to the sorted frequent item set set. The Zygote container is generated by the method more easily and can be started quickly by as many function applications as possible, thereby improving the starting efficiency.

[0068] Obviously, the above embodiments of the present application are merely exemplary but not intended to limit the embodiments of the present application. Based on the above description, any other variations or changes can be made by those skilled in the art without departing from the spirit and principles of the present application. It is not necessary to list all the embodiments here. Any modifications, equivalent replacements, and improvements made within the spirit and principles of the present application should be included in the protection scope of the claims of the present application.

Claims

1. A method for fast start of services based on Zygote containers in serverless edge cloud, characterized in that, The method comprises the following steps: S1: obtaining a function set to be called and function dependency package information of all functions in the function set; The function set to be called comprises a plurality of functions; S2: obtaining a frequent item set set composed of all dependency package frequent item sets according to the function dependency package information of all functions; S3: performing descending order sorting on the frequent item set set to obtain a sorted frequent item set set; S4: generating a Zygote container according to the sorted frequent item set set; S5: judging whether each function in the function set to be called can be started through the Zygote; if yes, starting the function through the Zygote; if not, starting the function through a cold start; In step S1, the function set comprises dependency package basic information of all functions and cold start time of each function; each dependency package basic information comprises a size of the dependency package and an introduction time of the dependency package; The function set to be called is F, a set of function dependency packages of all functions in the function set is P, and a memory size of the server is M; Definition β fp ∈{0,1} represents whether the function f∈F needs to rely on the package p∈P, β fp =1 means that it is needed, β fp =0 means that it is not needed, the function f = <β fp1 ,β fp2 ,…,β fp|P| >, the cold start time of the function f∈F is τ f , according to the value of each β fp of the function f, the function f needs to rely on the package {p i ,p j ,…,p k} is obtained; the size of a dependent package p∈P is defined as S p , and the calling time is τ p , and the dependent package p = <S p ,τ p > ∈P is obtained. In step S5, including: for a function f e F, if there exists β fp e f, where p e P, the dependent package p corresponds to a p in the Zygote in the server, has then set γ f 0, indicating that the function f cannot use the Zygote in the server; otherwise, set γ f 1, indicating that the function f can use the Zygote in the server; In step S5, further comprising: calculating the startup time of each function in the function set, and calculating the total startup time, specifically comprising: for each current server called function set F, if γ f =1, the function f can use the Zygote of the server, the function f only needs to call the dependent package required by the function but not contained in the Zygote, and the calling package time of the function f is t w (f) =∑ p∈P γ f β fp (1-α p )τ p ; otherwise, γ f =0, the function f cannot use the Zygote of the server, the function f can only be cold started, and the cold start time of the function f is t c (f) = (1-γ f )τ f ; the startup time of the function f is t s (f) = t c (f) + t w (f) ; finally, the total startup time T =∑ f∈F t s (f) of the service composed of the startup time of all functions in the function set F is calculated.

2. The method of claim 1, wherein the method further comprises: In step S2, it includes: according to the function dependency package information of all functions, using FP-growth algorithm, in the case of minimum support degree 1, all frequent item sets are solved, the mode of frequent item set is δ={p′ i ,p′ j ,…,p′ k :count}∈I, wherein, p′ i ,p′ j ,…,p′ k ∈P, P is the set of function dependency packages of all functions in the function set, count is the appearance frequency of the frequent item set, I represents the set composed of all frequent item sets.

3. The method of claim 1, wherein the method further comprises: In step S3, it includes: sorting each frequent item set in the frequent item set set in descending order according to the frequency of occurrence. If the number of occurrences of several frequent item sets is the same, then sorting these frequent item sets in descending order according to the total memory size occupied by the dependent packages in each frequent item set to obtain the final sorting result; specifically, sorting all frequent item sets {δ1,δ2,…,δ |I| }, sort by the descending order of the frequency count of each δ∈I; if some of the frequent item sets in the frequent item set {δ i ,δ j ,…,δ k } have the same frequency of occurrence, then the total memory occupied by all dependent packages of each frequent item set δ in the frequent item set with the same frequency is S=∑ p∈ω S p , sort them in descending order to get the sorted frequent item set.

4. The method of claim 1, wherein the method further comprises: In step S4, the following steps are included: S4.1: selecting a most leading frequent item set δ∈I from the sorted frequent item set set; S4.2: judging whether a total memory occupation size S of the most leading frequent item set exceeds a memory size M allocated by the server for generating the Zygote; if yes, removing the most leading frequent item set selected currently from the sorted frequent item set set, and returning to step S4.1 after the removal is completed; if S≤M, generating the Zygote according to the most leading frequent item set.

5. The method of claim 4, wherein the method further comprises: In step S4.1, the following steps are included: selecting a most leading frequent item set δ∈I from the sorted frequent item set set; the most leading frequent item set δ∈I refers to that, in the sorted frequent item set set, a frequency count of a frequent item set is the most, and in a plurality of frequent item sets with the same frequency count, a total size S of all dependency packages of the frequent item set is the largest among the frequent item sets.

6. The method of claim 4, wherein the method further comprises: In step S4.2, the expression of the total memory occupation size S of the dependent bag of the frequent item set δ is: S = ∑ p∈δ S p ; the total memory occupation size S is compared with the memory size M allocated by the server; if S > M, the current selected frequent item set δ is removed from the current frequent item set set I, the expression is I = I - δ, and after the removal, the step S4 is returned; if S ≤ M, the Zygote is generated according to the most front frequent item set. Generating the Zygote according to the top frequent item set includes: for each dependent package p e δ in the top frequent item set, setting α p in the Zygote corresponding to the dependent package p to 1.

7. A Zygote container based service fast launch system in serverless edge cloud characterized by, The method comprises the following steps: An obtaining module: obtaining a function set to be called and function dependency package information of all functions in the function set; The function set to be called comprises a plurality of functions; A set module: obtaining a frequent item set set composed of all dependency package frequent item sets according to the function dependency package information of all functions; An ordering module: performing descending order sorting on the frequent item set set to obtain a sorted frequent item set set; A Zygote container module: generating a Zygote container according to the sorted frequent item set set; A starting module: judging whether each function in the function set to be called can be started through the Zygote; if yes, starting the function through the Zygote; if not, starting the function through a cold start; In the obtaining module, the function set comprises dependency package basic information of all functions and cold start time of each function; each dependency package basic information comprises a size of the dependency package and an introduction time of the dependency package; The function set to be called is F, a set of function dependency packages of all functions in the function set is P, and a memory size of the server is M; Definition β fp ∈{0,1} represents whether the function f∈F needs to depend on the package p∈P, β fp =1 means it needs, β fp =0 means it does not need, the function f = <β fp1 , β fp2 , …, β fp|P| >, the cold start time of the function f∈F is τ f , according to the value of each β fp of the function f, the function f needs the dependent package {p i , p j , …, p k}; define the size of a dependent package p∈P as S p , and the call time is τ p , get the dependent package p = <S p , τ p >∈P; In the starting module, including: for a function f e F, if there exists β fp e f, where p e P, the dependent package p has a corresponding a p in the Zygote in the server, has Then set γ f 0, indicating that the function f cannot use the Zygote in the server; otherwise, set γ f 1, indicating that the function f can use the Zygote in the server; In the starting module, further comprising: calculating the starting time of each function in the function set, and calculating the total starting time, specifically comprising: for each current server called function set F, if γ f =1, the function f can use the Zygote of the server, the function f only needs to call the dependent package required by the function but not contained in the Zygote, and the calling package time of the function f is t w (f) =∑ p∈P γ f β fp (1-α p )τ p ; otherwise, γ f =0, the function f cannot use the Zygote of the server, the function f can only be cold started, and the cold start time of the function f is t c (f) = (1-γ f )τ f ; the starting time of the function f in F is t s (f) =t c (f) +t w (f) Finally, the total service startup time T =∑ is calculated from the startup times of all functions in the function set F. f∈F t s (f).

Images