Patent Grant
12131196
This is a U.S. national phase application under 35 USC 371 of international application PCT/JP2019/043067, (not published in English) filed on Nov. 1, 2019, which claims priority to Japanese patent application No. 2018-240059, filed on Dec. 21, 2018. The entire disclosures of the above applications are incorporated herein by reference.
An aspect of the present invention relates to a distributed processing support apparatus for supporting distributed processing of an application on multiple information processing devices, a distributed processing support method, and a program.
With the recent development of Internet-of-Things (IoT) technologies, various kinds of familiar devices have become accessible to the Internet, which makes it easier to collect and utilize information acquired by these devices.
With this in the background, expectations are increasing for distributed applications, in which multiple application logic operations (which denote a kind of processing performed upon input data to output data; hereinafter simply referred to as “logics”) such as functions and classes are deployed to and executed on geographically distributed machines in order to enhance the information acquisition efficiency and response time reduction.
For instance, through deployment of a logic for aggregating information transmitted from IoT devices in relay servers, the amount of communication required for information acquisition can be reduced. In addition, through deployment of a logic that carries out frequent communications with user terminals in a server geographically adjacent to the users of the application, the application response time can be reduced.
In order to execute an application in a distributed manner among multiple machines, the application needs to be partitioned into multiple logic operations and deployed to multiple machines (see Non-patent Literature 1, for example).
The performance of the application varies greatly depending on how the application is partitioned and how it is deployed. Such a variation is produced because the communications among logics need to be performed through communications among machines and also because the logic processing time is highly dependent on the performance of the machine that executes this logic. For this reason, to maximize the application performance, the technique for determining the optimal partition and deployment of the application is desired.
In order to determine the optimal deployment, it is common practice to Convert the optimization problem to a linear programming problem having an objective function for the optimization of the application performance (factors relating to the traffic of machines, throughputs, processing time and the like), and to calculate the optimal solution for the optimal deployment. If the to-be-partitioned application or its operational environment is of a massive scale, however, the possible deployment patterns will be increased to an enormous number, which will make it impossible to calculate the optimal solution in real time. For instance, if 100 operations are obtained after the partition, and 3 machines are available as deployment candidates, there will be 5.2×1047 possible deployment patterns.
To solve such a problem, a technique of employing an approximate method such as simulated annealing or a genetic algorithm has been known (see Non-patent Literature 2, for example). The approximate method limits the deployment patterns to be explored, which realizes acquisition of a solution to the application deployment in a reduced time in comparison with a method of simply exploring all the deployment patterns. According to such application partition and deployment, the functions defined in the source code of the application are first partitioned as one logic, and thereafter, possible deployment patterns of the deployment candidate machines and functions are calculated, from which an approximate solution (quasi-optimal solution) of the deployment pattern that can deliver the highest application performance is selected.
Specifically, according to the above conventional technique, logics (e.g., functions and classes) are first identified from the input source code, and the source code is partitioned in accordance with these logics. Multiple combination patterns of the logics and deployment candidate machines are thereby created. Thereafter, the application performance of each deployment pattern is measured. For instance, the partitioned logics may be installed and repeatedly executed on the respective machines in accordance with each deployment pattern to determine the average time period required for the entirety of the processing to be the processing time of the function, or in other words the performance value of the deployment pattern. Based on the obtained performance value, an optimization problem such as the linear programming problem (see Non-patent Literature 3, for example) is solved with an approximate method such as simulated annealing and a genetic algorithm so that the deployment of logics that can deliver a high performance in the desired processing can be calculated. For instance, when the optimal solution is defined as “a deployment pattern that reduces the machine traffic most among the deployment patterns demonstrating the processing time of 500 milliseconds or less”, an approximate solution of this optimal solution may be calculated based on the communication traffic, the entire processing time, and network delay among machines in each deployment pattern.
Non-patent Literature 1 Alex Reznik, et al., “Developing Software for Multi-Access Edge Computing,” ETSI White Paper, No. 20, September 2017.
Non-patent Literature 2 Jieyao Liu, et. al., “Application Partitioning Algorithms in Mobile Cloud Computing: Taxonomy, Review and Future Directions,” Journal of Network and Computer Applications, vol. 48, 2015.
Non-patent Literature 3 IBM ILOG CPLEX, [online], Internet <URL:http://www.ilog.com/products/cplex/>
With the above-discussed conventional technique, an approximate solution of the deployment pattern that can deliver the highest application performance may be calculated at high speed. With the conventional technique adopting an approximate method, however, whether or not the solution is indeed optimal is not ensured.
To address this issue, a calculation scheme is required for efficiently calculating an application deployment without overlooking the optimal solution.
The present invention has been conceived in light of the above circumstances. The invention, aims to offer a technique for efficiently determining the optimal deployment for the application distribution processing.
To provide an answer to the above problem, a distributed processing support apparatus according to the first aspect of the present invention, which is configured to support distributed processing of an application on a plurality of information processing devices, includes a source code acquisition unit configured to acquire a source code of the application; a source code partition unit configured to partition the source code into a plurality of logics; a candidate extraction unit configured to, based on a processing order of the logics of the application and information concerning operational environments of the information processing devices, extract deployment pattern candidates of the logics which are to be deployed in a distributed manner to any of the information processing devices; and an optimal pattern determination unit configured to determine an optimal deployment pattern from the extracted deployment pattern candidates.
According to the first aspect of the invention, a distributed processing support apparatus for assisting the application distribution processing on the multiple information processing devices partitions the source code of the application into multiple logics, extracts candidate deployment patterns of the logics to the information processing devices based on the processing order of the partitioned logics and information concerning the operational environment of the information processing devices, and determines the optimal deployment pattern from these candidates. Since deployment pattern candidates of the partitioned logics are extracted before determining the optimal deployment pattern, the determination of the optimal deployment pattern can be efficiently made in comparison with the determination of the optimal solution from the deployment patterns for all the possible combinations.
That is, according to the present invention, the technique for efficiently determining the optimal deployment for the application distribution processing can be offered.
Embodiments of the present invention will be described below with reference to the drawings.
(Configuration)
(System Configuration)
The system includes terminal devices TDI to TDi (hereinafter they may also be referred to as “terminal devices TD” without differentiating between them), which serve as data collection source machines or input source machines, and sensors SS1 to SSj (hereinafter they may also be referred to as “sensors SS” without differentiating between them); multiple cloud servers CSV1 to CSVn (hereinafter they may also be referred to as “cloud servers CSV” without differentiating between them), which acquire data from these devices via a network NW; multiple edge servers ESV1 to ESVm (hereinafter they may also be referred to as “edge servers ESV” without differentiating between them) arranged between the terminal devices TD/sensors SS and the cloud servers CSV; and a distributed processing support apparatus 1 according to the present embodiment communicable with these devices via a network NW.
The network NW may include a public network such as the Internet and an access network for accessing this public network. The access network also includes an edge network ENW for mutually connecting the edge servers ESV. The edge network ENW may be formed by a local area network (LAN) or wireless LAN. The edge server ESV may bypass an edge network ENW to be directly connected to the Internet.
The terminal devices are information processing devices with a communication function, such as smartphones and personal computers, which can use cloud applications by way of one or more edge servers ESV. The sensors SS include automobiles and other IoT devices. The sensing data measured or detected by a sensor SS is transmitted through a wireless interface adopting a power-saving wireless data communication protocol such as a LAN, wireless LAN, or Bluetooth (trademark), or through a terminal device TD, to an edge server ESV preset as a transmission destination. The terminal devices TD and sensors SS are illustrated merely as examples. They may be stationary or mobile, and may include various numbers and types of devices. The terminal devices TD and Sensors SS do not always need to pass through an edge server ESV or edge network ENW, but may directly access a cloud server CSV through the network NW.
An edge server ESV constitutes a small-scale data center positioned near the user in comparison with a cloud environment expanded on a large-scale data center, and includes various types of information processing devices such as server computers and personal computers.
A cloud server CSV is formed by an information processing device such as a cloud computer, receiving and storing sensing data transmitted from the edge servers ESV through the network NW.
The cloud server CSV offers applications available in the cloud environment. The applications provided by the cloud servers CSV include distribution applications. A distribution application can be processed in a distributed manner by any number of edge servers ESV and terminal devices TD in addition to the cloud server CSV.
The distributed processing support apparatus 1 may be a server computer or personal computer operable by a system manager to determine the deployment of such a distribution application and thereby assist the application distributed processing.
The distributed processing support apparatus 1 includes a communication interface unit 10, a processing unit 20, and a storage unit 30.
The communication interface unit 10 may include a wired or wireless interface, enabling information transmission/reception through the network NW with a cloud server CSV, an edge server ESV, or a terminal device TD.
For the storage unit 30, a nonvolatile memory such as a hard disk drive (HDD) or a solid state drive (SSD), on which write and read operations can be performed at any time, may be adopted as a storage medium. As the necessary storage regions to realize this embodiment, the storage unit 30 includes an application information storage unit 31, a partition rule storage unit 32, and an operational environment information storage unit 33 in addition to a program storage unit.
The application information storage unit 31 is used for storage of information concerning the distributed processing target application. The application related information may include the processing order of functions in the source code of the application and information concerning the input/output of this application.
The partition rule storage unit 32 is used for storage of rules relating to the partition of an application. The rules relating to the partition of an application are employed to identify partitionable logics, for example based on information concerning the functions defined by the application developers. The rules relating to the partition of the application may be prestored in the partition rule storage unit 32 by a system manager, or may be acquired together with the to-be-partitioned application information through the network NW.
The operational environment information storage unit 33 is used for storage of information concerning the operational environment of information processing devices (which may also be referred to as “machines”) that may be involved in the distributed processing. The operational environment information storage unit 33 may store information concerning the computational capabilities, storage regions, present locations and the like of individual machines, which may be input in advance by a system manager. Such information may be updated based on the latest information acquired through the network NW.
The storage units 31 to 33 do not always need to be provided in the distributed processing support apparatus 1, and may be an externally provided storage medium such as a USB memory, or a storage device such as a database server on the cloud. The distributed processing support apparatus 1 may access the database server on the cloud through the communication network NW to acquire and use the necessary data.
The processing unit 20 includes a hardware processor (not shown) such as a central processing unit (CPU) and microprocessing unit (MPU), and a memory such as a dynamic random access memory (DRAM) and a static random access memory (SRAM). As the necessary processing functions to carry out this embodiment, the processing unit 20 includes a source code acquisition unit 21, a source code partition unit 22, a deployment pattern candidate extraction unit 23, and an optimal pattern determination unit 24. These processing functions are realized by the processor executing the programs stored in the storage unit 30. The processing unit 20 may be realized in various manners, for example as an integrated circuit such as the application specific integrated circuit (ASIC) and field-programmable gate array (FPGA).
The source code acquisition unit 21 executes a process for acquiring the source code of the distributed processing target application via the communication interface unit 10. The source code acquisition unit 21 may be configured to receive the source code through the network NW from a management server (not shown) that manages the applications on the cloud, or to acquire the source code input by the system manager on an input device (not shown). The source code acquisition unit 21 further executes a process for extracting information concerning the target application based on the acquired source code and storing the information in the application information storage unit 31.
Following the partition rules stored in the partition rule storage unit 32, the source code partition unit 22 executes a process for identifying partitionable logics (functions and classes) from the source code acquired by the source code acquisition unit 21 and partitioning the source code in accordance with the identified logics.
The deployment pattern candidate extraction unit 23 executes a process for extracting deployment pattern candidates that have a possibility of being the optimal solution from the deployment patterns of the logics partitioned by the source code partition unit 22 and the deployment destination machines.
The optimal pattern determination unit 24 is configured to determine the optimal deployment pattern from the deployment pattern candidates extracted by the deployment pattern candidate extraction unit 23. The optimal pattern determination unit 24 includes an application performance measurement unit 241 and an optimal pattern selection unit 242.
The application performance measurement unit 241 executes a process for measuring or calculating the performance of the application (app) for each of the deployment pattern candidates extracted by the deployment pattern candidate extraction unit 23.
Based on the measured or calculated application performance, the optimal pattern selection unit 242 executes a process for selecting a deployment pattern delivering the optimal performance as the optimal deployment pattern.
(Operations)
The information prods sing operation of the distributed processing support apparatus 1 having the above configuration will be explained below.
(1) Reception of Initiation Trigger
At step S1, the distributed processing support apparatus 1 monitors a trigger for initiating the process for determining the distribution and deployment of an application. Under this situation, an application developer or system manager inputs an initiation request for the distribution/deployment determination on the management terminal (not shown). Upon receipt of this initiation request as a trigger, the distributed processing support apparatus 1 executes the following operations.
(2) Acquisition of Source Code
At step S2, the distributed processing support apparatus 1 acquires at the source code acquisition unit 21 a source code of the distributed processing target application from the application management server (not shown) through the network NW under the control of the processing unit 20. The source code acquisition unit 21 sends the acquired source code to the source code partition unit 22, and stores the information relating to the source code or the application in the application information storage unit 31. The application related information includes the processing order of functions in the source code of the application, input data to the application, an input source machine, output data from the application, and an output destination machine. The source code of the application may be acquired from the management terminal that the application developer or system manager uses.
(3) Division of Source Code
At step S3, the distributed processing support apparatus 1 identifies at the source code partition unit 22, partitionable logics (such as functions and classes) in the acquired source code and partitions the source code into logics in accordance with the partition rules prestored in the partition rule storage unit 32, under the control of the processing unit 20.
(4) Extraction of Deployment Pattern Candidates
At step S4, the distributed processing support apparatus 1 executes at the deployment pattern candidate extraction unit 23 a process for extracting possibly optimal deployment patterns as deployment pattern candidates under the control of the processing unit 20. This process will be explained in detail below.
(4-1) Overview of Extraction Process
When the information concerning the processing order of the logics of the target application and the data input source and output destination machines is fixed, and if a reduced application processing time and a reduced communication volume among machines are aimed at, deployment patterns include some apparently non-optimal deployment patterns.
In the extraction of deploythent pattern candidates, the distributed processing support apparatus 1 according to the present embodiment removes these apparently non-optimal deployment patterns in advance based on the processing order of the logics of the application and the information concerning the input source machine that inputs data to the partition target application and the output destination machine to which the data from the application is output, thereby finding the optimal solution from essential patterns only. With such an extraction process, the number of deployment pattern candidates can be reduced without overlooking the optimal solution.
(4-2) Removal of Non-Optimal Deployment Patterns Based on Directed Graph
In
A large number of deployment patterns P1 to Pn can be considered for the deployment of the partitioned functions to the machines, and among these deployment patterns, the optimal solution (pattern P59 in the example of
If the reduction of the entire processing time of the application is aimed at on the aforementioned assumption, the deployment pattern P3 is apparently not an optimal deployment pattern of the deployment patterns illustrated in
In general, a deployment pattern that cannot be optimal (hereinafter referred to as “non-optimal deployment pattern”) can be expressed in the manner indicated below.
<Non-Optimal Deployment Pattern>
The deployment Pattern will not be optimal if a graph of this deployment pattern created by connecting the machines in the function processing order with directed edges (hereinafter referred to as a “process flow graph”) matches neither graph G1 nor G2 indicated below.
(4-3) Proof of Non-Optimal Deployment Pattern
The following proves that, in an environment where the logic processing order, data input source machine, and data output destination machine have already been determined, and where the reduction in the application processing time and in communication volume is aimed at, a deployment pattern that matches neither graph G1 nor G2 is not optimal.
[Assumption]
It is assumed that the deployment pattern A is the optimal solution, where the deployment pattern A has a process flow graph that matches neither the shortest directed path group nor the shortest directed cycle group that passes through each of the deployment candidate machines one or fewer times in ascending order of their computational capabilities, with the data input source machine determined to be the point of origin and the data output destination machine determined to be the point of destination.
[Proof]
In the deployment pattern A of
In order for the deployment pattern A to not include a directed edge e having an inverse direction, the logic lb is moved from the machine mb to the machine ma, and the resultant deployment pattern will be referred to as deployment pattern A′.
In the shortest directed path or cycle, the machines are connected by directed edges in processing order, where ma demonstrates a higher computational capability than that of mb. For this reason, in comparison with the deployment pattern A, the deployment pattern A′ exhibits a shorter processing time of the logic lb and a communication volume that is smaller by the data flow volume flowing along the directed edge e. That is, the deployment pattern A′, which exhibits a shorter processing time and a smaller communication volume than the deployment pattern A, contradicts the assumption that the deployment pattern A is the optimal solution.
In view of the above, if a deployment pattern has a process flow graph that does not match either one of the shortest directed path group or shortest directed cycle group that passes each of the deployment candidate machines one or fewer times in ascending order of their computational capabilities, with the data input source machine serving as a point of origin and the data output destination machine serving as a point of destination, this deployment cannot be considered to be an optimal deployment pattern (i.e., can be considered to be a non-optimal deployment pattern).
(4-4) Exemplary Algorithm
In the fifth and seventh lines of the algorithm 1 in
Then, the following six deployment patterns can be obtained:
After deployment pattern candidates are extracted in the above manner, at step S5 in
Next, at step S6, the distributed processing support apparatus 1 determines, at the optimal pattern selection unit 242 of the optimal pattern determination unit 24, the deployment pattern producing the optimal performance to be the optimal deployment pattern, based on the measured or calculated application performance. For instance, based on the time period required for the entirety of the processing calculated by the application performance measurement unit 241, the optimal pattern selection unit 242 may select the deployment pattern having the shortest period as the optimal deployment pattern. Alternatively, the optimal pattern selection unit 242 may select the deployment pattern having the least traffic volume among the machines, or the least network delay among the machines, as the optimal pattern. The configuration of the optimal pattern determination unit 24 can be freely set by the system manager, and therefore the optimal deployment pattern that meets the purpose of the distributed processing system can be determined.
First, at step S101, the distributed processing support apparatus 1 according to the present embodiment identifies logics (e.g., functions and classes) from the source code of the input application P, and partitions the source code in accordance with these logics, under the control of the source code partition unit 22.
Next, at step S102, the distributed processing support apparatus 1 extracts, as candidates, only deployment patterns demonstrating the possibility of being an optimal solution based on the partitioned logics and the information of the operational environment of the application (deployment candidate machines and their computational capabilifies) under the control of the deployment pattern candidate extraction unit 23. Here, the algorithm 1 of
At step S103, the distributed processing support apparatus 1 measures the application performance value at the runtime of the distribution application with each of the deployment patterns, under the control of the application performance measurement unit 241.
At step S104, the distributed processing support apparatus 1 explores only the extracted deployment patterns based on the measured application performance values, and selects the deployment pattern of logics exhibiting the highest performance, under the control of the optimal pattern selection unit 242.
In the example of
(Verification of Effectiveness)
To verify the effectiveness of the above technique, a simulation test was conducted under the following environment.
Five deployment candidate machines are provided, with the input source machine having the lowest computational capability, and the output destination machine having the highest computational capability.
The partition/deployment target application includes 2 to 10 functions, which are sequentially called. The function including the input processing corresponds to the root of the data-flow graph, while the function including the output processing corresponds to a leaf of the data-flow graph.
The processing time of each function is randomly set in a manner such that the time period is shorter as the function installed in a machine has a higher computational capability. The communication volume among the functions is randomly set, and the communication delay among the machlnes increases as the communication volume increases.
In the above environment, the test was repeated a hundred times while changing the random number every time to calculate the average values of the following indicators.
As comparative methods, the simple scheme (naive) of exploring all the deployment patterns, and simulated annealing (SA) (see Verbelen, Tim, et al., “Graph partitioning algorithms for optimizing software deployment in mobile cloud computing,” Future Generation Computer Systems, vol. 29, No. 2, pp. 451-459, 2013) are adopted. With the simulated annealing, starting from a randomly selected initial solution, an exploration is conducted in the direction of improving the performance of this solution, and the solution obtained through a predetermined number of explorations is output as an approximate solution in this experiment, an evaluation is performed by setting the number of explorations in the simulated annealing to be the same as the number of deployment patterns of the present invention.
The above embodiment is applicable to a data-flow graph including a cycle. For instance, the data-flow graph may be partitioned into multiple directed paths, and the above embodiment may be applied to each of the directed paths. In this manner, the number of deployment patterns can be reduced.
As a result of the application of the present embodiment, the optimal deployment pattern P1′ is determined for the directed path 1′, as illustrated in FG3. In this example, A and B are deployed to the machines X; C, D, and E are deployed to the machine Y; and F is deployed to the machine Z. With the optimal deployment pattern P1 determined for the directed path 1′, the data input source machine (machine for processing B) and data output destination machine (machine for processing E) are simultaneously determined for the directed path 2′. On the precondition of using this input source machine and output destination machine, the present embodiment is next applied to the directed path 2′. In the example of
As described above, even if the data-flow graph includes a cycle, the present embodiment is still easily applicable thereto.
(Effects)
As discussed above, according to the embodiment of the present invention, a source code of the application is acquired; the source code is partitioned into a plurality of logics; and based on a processing order of the logics of the application and information concerning operational environments of the information processing devices, deployment pattern candidates of the logics which are to be deployed in a distributed manner to any of the information processing devices are extracted. Then, an optimal deployment pattern for deploying the logics of the distribution application is determined from the extracted deployment pattern candidates.
In general, when the deployment problem of the logics of an application is to be solved as an optimization problem to improve the performance of the distribution application, the optimization of a solution is traded off against the number of to-be-explored deployment patterns. The conventional approximate method for calculating the optimal deployment pattern may realize a high-speed calculation, but the method does not ensure the optimality of the solution, which makes it difficult to acquire the optimal deployment pattern.
According to the present embodiment, to address this issue, the relationship among the processing order of the logics in the application, the computational capabilities of the deployment candidate machines, and objective functions for the application deployment is focused on, as a result of which the number of to-be-explored deployment patterns is considerably reduced, while the optimal solution is preserved in these to-be-explored deployment patterns. That is, only possibly optimal deployment patterns are extracted (or conversely, unlikely deployment patterns are removed (pruned)) to reduce the number of to-be-explored deployment patterns. Thus, without overlooking the optimal solution, the optimal application distribution and deployment can be quickly and efficiently calculated.
In addition, as mentioned earlier, the present embodiment is applicable to a data-flow graph including a cycle. The number of deployment patterns can be reduced, without overlooking the optimal solution.
The present invention is not limited to the above embodiments.
According to the present embodiment, the machines X, Y, and Z are described as exemplary deployment destinations of a distribution application. In particular, in the example of the present embodiment, the machine X is a terminal device TD such as a smartphone, the machine Y is an edge server ESV, and the machine Z is a cloud server CSV. This is not a limitation, however. The machine X, machine Y, and machine Z that serve as deployment destinations of the distribution application may all be cloud servers CSV, edge servers ESV, or smartphones. Alternatively, the machine X, machine Y, and machine Z that serve as deployment destinations of the distribution application may be any two of a cloud server CSV, an edge server ESV, and a smartphone.
The number of deployment destination machines is not limited to two or three, and any desired number can be determined to satisfy the desired level of the application performance.
Furthermore, the partition rules of a source code are not limited to the partition in units of functions defined by the application developer, and the source bode may be partitioned in larger or smaller units than any predetermined reference size.
Alternatively, the units 21 to 24 of the distributed processing support apparatus 1 may be arranged in a cloud computer, an edge router and the like in a distributed manner such that these devices can function through mutual cooperation to execute the above process.
In addition, the algorithm for extracting deployment pattern candidates that are likely to be the optimal solution may be modified in various manners within the gist of the present invention.
For instance, in one aspect of the above embodiment, the distributed processing support apparatus (1) configured to support distributed processing of an application on a plurality of information processing devices may include: a source code acquisition unit (21) configured to acquire a source code of the application; a source code partition unit (22) configured to partition the source code into a plurality of logics; a candidate extraction unit (23) configured to, based on a processing order of the logics of the application and information concerning operational environments of the information processing devices, extract deployment pattern candidates of the logics which are to be deployed in a distributed manner to any of the information processing devices; and an optimal pattern determination unit (24) configured to determine an optimal deployment pattern from the extracted deployment pattern candidates.
In the second aspect, the candidate extraction unit (23) according to the first aspect may remove a deployment pattern having a path that is not the shortest, using a directed graph that represents the information processing devices as nodes and a directed edge identifying a processing order of the logics in the application as a path, to extract the deployment pattern candidates.
In the third aspect, the candidate extraction unit (23) according to the first aspect may extract, using a directed graph that represents the information processing devices arranged in ascending order of computational capabilities as nodes and a directed edge identifying a processing order of the logics in the application as a path, deployment patterns having a shortest path as the deployment pattern candidates.
In the fourth aspect, the optimal pattern determination unit (24) according to the first aspect may include a performance measurement unit (241) configured to measure an application performance of each of the extracted deployment pattern candidates for an entirety of processing when the application is executed; and an optimal pattern selection unit (242) configured to select a deployment pattern providing best performance from the deployment pattern candidates based on a measurement result of the performance of the application.
In the fifth aspect, according to the fourth aspect, the performance measurement unit (241) may calculate, as the application performance, at least one of a time required for completion of the entire processing, a traffic volume between the information processing devices, and a network delay between the information processing devices.
According to the present embodiment, the distributed processing support apparatus for assisting the application distribution processing on multiple information processing devices partitions the source code of an application into multiple logics, extracts candidate deployment patterns of the logics to the information processing devices based on the processing order of the partitioned logics and information concerning the operational environment of the information processing devices, and determines the optimal deployment pattern from these candidates. Since deployment pattern candidates of the partitioned logics are extracted before determining the optimal deployment pattern, the determination of the optimal deployment pattern can be effectively made, in comparison with the determination of the optimal solution from the deployment patterns for all the possible combinations.
In addition, according to the present embodiment, a directed graph, which represents as nodes the information processing devices that serve as the deployment destinations of the partitioned logics and represents as directed edges the processing order of the logics, is employed to extract deployment pattern candidates while removing paths that are not the shortest. Since the paths not shortest and thus unlikely to be the optimal solution are removed (pruned), an effective, the optimal exploration can be realized with the reduced number of to-be-explored patterns, while preserving the deployment patterns that are possibly the optimal solution in the candidates.
According to the present embodiment, a directed graph representing information processing devices arranged in ascending order of their computational capabilities as nodes, and representing the processing order of the logics by directed edges, is employed to extract deployment patterns having the shortest path as deployment pattern candidates. As a result of extraction of the shortest path as a candidate by arranging the information processing devices in ascending order of their computational capabilities and using them as nodes of the directed graph, non-optimal solutions can be removed, with which offloading may occur, as the logic processing proceeds, from an information processing device with a high computational capability to an information processing device with a low computational capability. Thus, the optimal exploration can be efficiently conducted.
According to the present embodiment, the application performance is measured when the application is executed for each of the extracted deployment pattern candidates, and the optimal deployment pattern is Selected based on the measurement results. Since the optimal deployment pattern is selected from the extracted deployment pattern candidates based on the performance of the application, a highly reliable exploration for the optimal solution can be conducted.
According to the present embodiment, at least one of the time period required for the entirety of the processing, traffic volume among information processing devices, and network delay is measured as the application performance. Since the optimal deployment pattern is determined from the extracted deployment pattern candidates based on the processing time for the entire application, traffic volume, or network delay, a highly reliable exploration for the optimal solution can be conducted in accordance with the purpose of the distributed processing.
The specific embodiments have been explained above, which are merely to present examples, and not to restrict the scope of the invention. Indeed, the novel embodiments described in this specification can be realized in various other modes. In addition, various omissions, replacements, and modifications may be made to the embodiments described in the specification without departing from the scope of the invention. The attached claims and their equivalents intend to cover such modes and modifications included in the gist and scope of the present invention.
| Number | Date | Country | Kind |
|---|---|---|---|
| 2018-240059 | Dec 2018 | JP | national |
| Filing Document | Filing Date | Country | Kind |
|---|---|---|---|
| PCT/JP2019/043067 | 11/1/2019 | WO |
| Publishing Document | Publishing Date | Country | Kind |
|---|---|---|---|
| WO2020/129432 | 6/25/2020 | WO | A |
| Number | Name | Date | Kind |
|---|---|---|---|
| 9542219 | Bryant | Jan 2017 | B1 |
| 11461669 | von Trapp | Oct 2022 | B2 |
| 20050125772 | Kohno | Jun 2005 | A1 |
| 20130097293 | Gibson | Apr 2013 | A1 |
| 20140282563 | Jacobson | Sep 2014 | A1 |
| 20150052530 | Jacobson | Feb 2015 | A1 |
| 20180081719 | Baldwin | Mar 2018 | A1 |
| 20180152361 | Chu | May 2018 | A1 |
| Number | Date | Country |
|---|---|---|
| H06-75786 | Mar 1994 | JP |
| 2005-173788 | Jun 2005 | JP |
| 2017-143365 | Aug 2017 | JP |
| Entry |
|---|
| Alex Reznik, et al., “Developing Software for Multi-Access Edge Computing,” ETSI White Paper, No. 20, Sep. 2017. |
| Jieyao Liu, et al., “Application Partitioning Algorithms in Mobile Cloud Computing: Taxonomy, Review and Future Directions,” Journal of Network and Computer Applications, vol. 48, 2015. |
| IBM ILOG CPLEX, [online], Internet URL :http://www.ilog.com/products/cplex/, Nov. 6, 2018. |
| Verbelen, Tim, et al., “Graph partitioning algorithms for optimizing software deployment in mobile cloud computing,” Future Generation Computer Systems, vol. 29, No. 2, pp. 451-459, 2013. |
| International Search Report issued in PCT/JP2019/043067 (in English and Japanese), mailed on Feb. 4, 2020. |
| Number | Date | Country | |
|---|---|---|---|
| 20220068126 A1 | Mar 2022 | US |
