KR20170071381A - Mobile fog computing system for performing multi-agent based code offloading and method thereof - Google Patents
Mobile fog computing system for performing multi-agent based code offloading and method thereof Download PDFInfo
- Publication number
- KR20170071381A KR20170071381A KR1020150189609A KR20150189609A KR20170071381A KR 20170071381 A KR20170071381 A KR 20170071381A KR 1020150189609 A KR1020150189609 A KR 1020150189609A KR 20150189609 A KR20150189609 A KR 20150189609A KR 20170071381 A KR20170071381 A KR 20170071381A
- Authority
- KR
- South Korea
- Prior art keywords
- agent
- fog
- mobile
- basic
- basic block
- Prior art date
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F1/00—Details not covered by groups G06F3/00 - G06F13/00 and G06F21/00
- G06F1/26—Power supply means, e.g. regulation thereof
- G06F1/32—Means for saving power
- G06F1/3203—Power management, i.e. event-based initiation of a power-saving mode
- G06F1/3234—Power saving characterised by the action undertaken
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F15/00—Digital computers in general; Data processing equipment in general
- G06F15/16—Combinations of two or more digital computers each having at least an arithmetic unit, a program unit and a register, e.g. for a simultaneous processing of several programs
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/50—Allocation of resources, e.g. of the central processing unit [CPU]
- G06F9/5005—Allocation of resources, e.g. of the central processing unit [CPU] to service a request
- G06F9/5027—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals
- G06F9/505—Allocation of resources, e.g. of the central processing unit [CPU] to service a request the resource being a machine, e.g. CPUs, Servers, Terminals considering the load
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computer Hardware Design (AREA)
- Mobile Radio Communication Systems (AREA)
Abstract
A mobile fog computing system and method for performing multi-agent based code offloading are disclosed.
In this method, the mobile terminal divides the code of the application into a plurality of basic blocks and then offloads some basic blocks to a mobile fog. The mobile fog then selects a base agent among a plurality of agents to process the base block offloaded from the mobile terminal. Next, the base agent processes the basic block to be offloaded, and the plurality of agents manages a position for processing the offloaded basic block.
Description
The present invention relates to a mobile fog computing system and method for performing multi-agent based code offloading.
Mobile cloud computing technology, which is different from conventional cloud computing, has emerged due to rapid development and spread of wireless network technology using a mobile terminal such as a smart phone.
Mobile cloud computing combines mobile computing with cloud computing, paying as much as you need to use it. Smart phones, as well as devices with mobility, such as notebooks, netbooks, and PDAs.
This mobile cloud computing differs from PC-based cloud computing centering on a large data center in that it allows consumers to share the CPU usage of mobile terminals and collects the remaining CPU resources to form one supercomputer.
On the other hand, in the mobile cloud computing described above, all the data must be transmitted from the mobile terminal to the cloud through the network and processed. Therefore, the processing through the mobile cloud computing during the processing of the big data based data such as the Internet of Things Based on the possibility of a problem, a large amount of data can be transmitted to a large data server in the distant place, that is, to the cloud, ), A fog computing technology has been proposed.
However, in the case of a mobile fog performing such fog computing, only the content for processing a part of the application requested to be processed between the mobile terminal and the cloud is presented, and the method for processing the application in the mobile terminal is presented more effectively I do not.
Therefore, there is a need for a mobile fork application system and method for mobile services that are more cost effective and ubiquitous scalable than mobile fog computing.
SUMMARY OF THE INVENTION The present invention provides a mobile fog computing system and method for performing multi-agent based code offloading capable of automatically and distributing processing of an application based on content-sensing.
A mobile fog computing method according to an aspect of the present invention includes:
The mobile terminal splitting the application code into a plurality of basic blocks and then offloading some basic blocks to a mobile fog; The mobile fog selecting a base agent among a plurality of agents to process a base block offloaded from the mobile terminal; And processing the basic block to be offloaded by the base agent, wherein the plurality of agents manage locations for processing the offloaded basic block.
Here, the location for processing the basic block may be a first location that is a location of a fog node belonging to a mobile fog to which the mobile terminal is connected; A second location that is the location of another mobile fog adjacent the mobile fog; And a third location where the mobile fog is a location of a clone connected via a communication network.
The plurality of agents may further include: a first agent for offloading the basic block to the first location; A second agent for offloading the basic block to the second location; A third agent for offloading the basic block to the third location; A fourth agent for offloading the basic block through migration from the first location to the second location; And a fifth agent for offloading the basic block through migration from the first location to the third location.
In addition, between the step of selecting the basic agent and the step of processing the basic block, the basic agent selects a cooperative agent among the plurality of agents for processing of a basic block capable of parallel processing with respect to the basic block ; And the basic agent and the cooperative agent form a computing unit to process the offloaded basic block.
In addition, the step of selecting the base agent may include: calculating an estimated response time using the resource information of the location managed by the plurality of agents, respectively; The plurality of agents each calculating a bead value using the estimated response time; And the mobile fog selecting the base agent using a bead value calculated for each of the plurality of agents.
Before each step of calculating the estimated response time, the plurality of agents check available resources at a location managed by the plurality of agents. And comparing the resources requested by the plurality of agents for processing of the basic block with the available resources, wherein the available resources are compared with resources requested for processing of the basic block to be offloaded And an agent responsible for a plurality of positions calculates the estimated response time.
In addition, the step of selecting the collaboration agent may include the steps of the base agent requesting collaboration with another agent; Receiving a collaboration response from the other agent; And selecting the collaboration agent from the agents capable of collaboration.
In addition, the step of selecting the cooperating agent among the cooperating agents may include determining whether the number of agents capable of cooperating is larger than the number obtained by subtracting the number of basic blocks that can be processed by the basic agent from the number of the basic blocks to be offloaded ; If the number of agents capable of cooperating is not greater than the number of basic blocks offloaded minus the number of basic blocks that can be processed by the basic agent, ; And if the number of agents capable of cooperating is larger than the number of basic blocks offloaded by subtracting the number of basic blocks that can be processed by the base agent from the number of basic blocks that are capable of cooperating, Selecting a number of cooperative agents equal to the number of basic blocks to be processed minus the number of basic blocks that can be processed by the basic agent.
Dividing the mobile terminal into basic blocks through application analysis before offloading the basic blocks to mobile fog; Collecting resource information for execution of the basic block through execution of the basic block; Calculating a host execution time when the mobile terminal executes the basic block; Requesting a fog execution time when the mobile fog is executed in the mobile fog while transferring resource information for execution of the basic block to the mobile fog; And offloading an offloadable basic block among the divided basic blocks to the mobile fog when the fog execution time transmitted from the mobile fog is less than the host execution time.
Further comprising the step of comparing resources required for execution of the basic block and resources available in the mobile terminal between a step of collecting the resource information and a step of calculating the host execution time, If the resources required for the execution of the basic block are larger than the available resources in the mobile terminal, performing the step of calculating the host execution time, And the mobile terminal processes the basic block.
In addition, the estimated response time (E ij )
Where E [N] is the estimated number of blocks on the fog node, P K is a stationary probability of finding a K block on a steady-state distribution or queue, L is the first position, L 2 is the second position, L 3 is the utilization factor, E [Q] is the estimated queue length of the mobile fog in the second position, L 1 is the first position, L 2 is the second position, the third position is, L 1,2 is a communication delay between L 1 and L 2, L 1, 3 is a communication delay between L 1 and L 3, P 0 is the probability no basic block in the queue being - Is calculated.
Further, the bead value (B ij )
- where i and j denote the location of the agent and the agent, respectively, Is a small constant called the risk factor of the beading of the agent a i , Is a normalization constant.
A mobile fog computing system according to another aspect of the present invention includes:
A mobile terminal for dividing an application code into a plurality of basic blocks and offloading some basic blocks to a mobile fog; And a base agent and a cooperative agent among a plurality of agents to process the basic block offloaded from the mobile terminal, and forming the base agent and the cooperative agent as a computing unit to distribute the offloaded basic blocks Wherein the plurality of agents manage positions for processing the basic blocks to be offloaded.
Here, the mobile terminal includes a compiler unit for converting a high-level language of an application into a low-level language of a machine-understandable type, and then dividing the low-level language into a plurality of basic blocks; And an offloading unit configured to determine whether offloading is to be performed for application execution using basic blocks of the application provided by the compiler unit, request code off loading of a basic block to the mobile fog when off-loading is required, And an application management unit for receiving the execution result of the basic block.
Also, the compiler unit may include a front end for generating an intermediate code by performing a grammar and a semantic analysis on a high-level language of the application; And generating a bytecode with respect to an intermediate code generated by the front end, dividing the low-level language code into a plurality of basic blocks through an independent byte code syntax, and then grouping the code into a plurality of basic blocks, And a back end that generates the data.
The application management unit may include an execution analyzer for collecting resource information required for execution of the basic block through execution of the application and for identifying a basic block that can be offloaded at the same time; And if offloading is possible, code offloading is performed while transferring resource information required for execution of the basic block and the basic block to the mobile fog, when offloading is possible, Includes the requesting code offloader.
In addition, the code offloader controls the off-loadable basic block to be executed where the time required for execution of the off-loadable basic block is calculated in the mobile terminal and the mobile fog.
The fog controller of the mobile fog manages the plurality of agents and selects the base agent and the cooperative agent among the plurality of agents to process a basic block offloaded from the mobile terminal, A multi-agent unit forming the cooperative agent as a computing unit; A code offloading unit for offloading the offloaded basic block to a corresponding location according to agent information belonging to a computing unit formed by the multi-agent unit, and controlling the offloading; And a control unit for controlling the multi-agent unit and the code off-loading unit to off-load basic blocks offloaded from the mobile terminal through the base agent and the computing unit.
Also, the multi-agent unit may calculate the estimated response time using the resource information available at a position of the plurality of agents, calculate the bead value corresponding to the plurality of agents using the calculated estimated response time, And the control unit selects a base agent to process the offloaded basic block and a cooperative agent to cooperate with the base agent based on the plurality of bead values for each agent.
In addition, the base agent selects the cooperative agent among the cooperative agents among other agents.
According to the present invention, the processing of an application can be distributed automatically and based on content-detection.
Thus, the execution time and delay of the application can be lowered, and the energy consumption of the mobile terminal can be lowered.
FIG. 1 is a block diagram illustrating a mobile fog computing system according to an embodiment of the present invention. Referring to FIG.
2 is a diagram schematically illustrating a code offloading framework in the mobile terminal shown in FIG.
FIG. 3 is a flowchart illustrating a process performed by the mobile terminal shown in FIG. 1. Referring to FIG.
4 is a diagram showing a specific configuration of the F-APC shown in FIG.
5 is a flow chart of a method of operation in a mobile terminal of a mobile fog computing method for performing multi-agent based code offloading according to an embodiment of the present invention.
6 is a flow chart of a method of operation in a mobile fog among a mobile fog computing method for performing multi-agent based code offloading according to an embodiment of the present invention.
FIG. 7 is a flowchart of a method of forming a computing unit in a mobile fog in a mobile fog computing method for performing multi-agent-based code offloading according to an embodiment of the present invention.
Hereinafter, embodiments of the present invention will be described in detail with reference to the accompanying drawings so that those skilled in the art can easily carry out the present invention. The present invention may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein. In order to clearly illustrate the present invention, parts not related to the description are omitted, and similar parts are denoted by like reference characters throughout the specification.
Throughout the specification, when an element is referred to as "comprising ", it means that it can include other elements as well, without excluding other elements unless specifically stated otherwise. Also, the terms " part, "" module," and " module ", etc. in the specification mean a unit for processing at least one function or operation and may be implemented by hardware or software or a combination of hardware and software have.
First, a system model for a mobile fog computing system to which the present invention is applied will be described.
Mobile cloud computing is a data distribution and processing distributed platform of mobile terminals to ensure quality of service for mobile users.
FIG. 1 is a block diagram illustrating a mobile fog computing system according to an embodiment of the present invention. Referring to FIG.
Referring to FIG. 1, a model of mobile cloud computing is introduced based on the fog computing model. In the mobile fog computing model according to the embodiment of the present invention, an LTE (Long Term Evolution) network is used to connect the
First, the
The
In this
AAA 41 is responsible for global authentication of
The P-GW 43 enables a PDN (Packet Data Network) access for the
Since the above-described configuration of the
On the other hand, the mobile fogs 20-1, 20-2, ..., 20-n are generated at edges in the network system except for the
In the mobile fog 20-1, 20-2, ..., 20-n, the APs 21-1 and 21-2 are responsible for providing a connection between the
The mobile fogs 20-1, 20-2, ..., 20-n are configured as a plurality of fog nodes. Specifically, one mobile fog 20-1 is an access point ) 21-1 and 21-2, and an access point controller (APC)
The APs 21-1 and 21-2 use an IEEE 802.11 WLAN interface with the
Like the APs 21-1 and 21-2, the
The upstream and downstream entities in this
As shown in FIG. 1, APs 21-1 and 21-2 and
Hereinafter, a code offloading framework according to an embodiment of the present invention will be described with reference to the drawings.
2 is a diagram schematically illustrating a code offloading framework in the
2, the
The compiler unit 310 converts the high-level language of the application into a machine-understandable low-level language.
The compiler unit 310 generates a bytecode for the intermediate code generated by the
The flow graph shown in Fig. 3 is used as an example, and the application is composed of six basic blocks from b 1 to b 6, and the six basic blocks are again a set of five compatible basic blocks It can be seen that they are grouped. Here, the register value of the block b 1 is used by the block b 3 and the block b 2, then block register values of b 2 is seen that is used by the block b 6, the blocks below may be used in this way . According to this flow graph, the five grouped sets of compatible are completely independent to enable parallel execution.
The
The
The
The
[Table 1]
The
Further, when the
The code offloader 322 offloads the code of the basic block to the fog nodes 21-1, 21-2, and 22 of the neighboring mobile fogs 20-1, 20-2, ..., 20- . Here, the availability of the fog node is realized through the
The code offloader 322 can distribute only the basic blocks that can be offloaded through the offload probability flag in Table 1 when offloading is required.
On the other hand, if the average CPU and memory usage of the basic block to be executed is less than or equal to the available memory and CPU in the
However, if the average CPU and memory usage of the basic block to be executed is greater than the memory and CPU available on the
The CPU and the memory usage history of the
Then, the code Offload to 322 compares the execution time when the fog (EET F) is passed, the two anticipated runtime result, that is the EET EET H F from the F-APC (22), EET F <EET H , the execution time in the mobile fogs 20-1, 20-2, ..., 20-n is shorter than that in the mobile fogs 20-1, 20-2, ..., 20-n Off loading.
However, EET F ≥ EET H , it is determined that the
On the other hand, the
The
The
Next, a method for performing multi-agent based code offloading according to an embodiment of the present invention will be described.
Hereinafter, for ease of explanation, it is assumed that the mobile terminal 30 requests code offloading to one mobile fog 20-1 because the code offload is required for the basic blocks.
The mobile fog 20-1 is arranged geometrically to serve close to the
Due to the dynamic resource requests from various
The three options for offloading the code are:
i) mobile in a mobile fog (or far away from the adjacent mobile fog 20-1 to handle a short mobile fog (20-1), L 1, ii ) mobility and load balancing problems in the
Here, L 1 denotes the position of the fog nodes 21-1, 21-2, 22 belonging to the mobile fog 20-1 where the F-
Multiple mobile agents are deployed to find the best option to offload the basic block of mobile code.
Fog mobile 20-1 for basic block offloading the mobile agent from the action space A is 1) a 1: Off-road position in the L 1, 2) a 2: off-loading at the location L 2, 3) a 3 : Offload at location L 3 , 4) a 4 : migration from location L 1 to L 2 , and 5) a 5 : migration from location L 1 to L 3 .
All of the multi-agents a 1 to a 5 are managed in the F-
Hereinafter, specific operations of the multi agents a 1 to a 5 will be described.
Each agent a i (where i is a natural number from 1 to 5) is responsible for the operations specified on a multi-agent basis as described above.
The agent a i calculates the bead B ij in accordance with the
[Equation 1]
Here, i and j represent agents and positions, respectively,
Is a small constant called the risk factor of the beading of the agent a i , Is a normalization constant.In an embodiment of the present invention, the estimated response time is considered to process the block as the estimation capability E ij .
Queuing theory (F-APC) 22 for analyzing the queue status of each fog node (i.e. F-
[Equation 2]
Here, E [N] is an estimated number of blocks on the fog nodes 21-1, 21-2, and 22 as shown in the following [Expression 3]. The steady-state distribution or the stationary probability of finding a K block on the queue is P K, and the utilization factor is
to be.[Equation 3]
Also, if it is contemplated to place the base block at location L 2 where the agent is a mobile fog, either adjacent or remote,
The queuing problem can be modeled. Where c is the number of servers in different groups. Estimated response time of the fog node in L 2 Is calculated as shown in [Equation 4].[Equation 4]
Here, E [Q] is the estimated length of the queue in the mobile fog L 2, L 1,2 is a communication delay between L 1 and L 2.
Also, if an agent is considered to place a base block at location L 3 in the
[Equation 5]
Where P 0 is the probability of no base block on the queue and L 1, 3 is the communication delay between L 1 and L 3 .
In summary,
The estimated response time E ij can be formulated as [Equation 6] as follows.
[Equation 6]
Therefore, the multi-agents a 1 through a 5 can calculate their respective bead values by using [Expression 1] using the estimated response time calculated according to [Expression 6] as the estimated ability E ij .
Hereinafter, the F-
FIG. 4 is a diagram showing a specific configuration of the F-
4, the F-
The
The
The
If the base agent to be responsible for code offloading is selected through the calculated bead value B ij by the agent, the base agent requests cooperation from other agents, receives a cooperation response from the other agents, And selects agents to perform processing together to form a computing unit.
The
In addition, the
Thereafter, the
The
Thereafter, when offloading of the basic block is requested from the mobile terminal 300, the
In addition, the
Although the
Also, the
Hereinafter, a mobile fog computing method for performing multi-agent based code offloading according to an embodiment of the present invention will be described with reference to the drawings.
First, a method for performing code offloading in the
5 is a flow chart of a method of operation in a mobile terminal of a mobile fog computing method for performing multi-agent based code offloading according to an embodiment of the present invention.
Referring to FIG. 5, the mobile terminal 30 forms a flow graph and a basic block through application analysis (S100)
Thereafter, the block to be tested is confirmed (S110), and run-time statistics are collected through execution of the application (S120). At this time, basic blocks that can be offloaded are identified.
Next, the resource required for executing the basic block to be offloaded is compared with the resources available in the mobile terminal 30 (S130), and the resources necessary for executing the basic block to which the resources available in the
Then, when the fog execution time EET F is received, it is determined whether it is smaller than the host execution time EET H (S160). That is, it is judged whether the execution time of the corresponding basic block in the mobile fog 20-1 is shorter.
If the fog execution time EET F is smaller than the host execution time EET H , the basic block is offloaded to the mobile fog 20-1 to be processed (S170) Receives the offload processing result, and ends the execution processing for the application (S180).
On the other hand, in the step (S140) the
Next, when the processing through the off-loading to the mobile fog 20-1 is judged to be more efficient than the processing in the
6 is a flow chart of a method of operation in a mobile fog among a mobile fog computing method for performing multi-agent based code offloading according to an embodiment of the present invention.
Referring to FIG. 6, the F-
Accordingly, the F-
Accordingly, each of the agents examines the resource statuses of the positions where they off-load the basic block, that is, L 1 , L 2, and L 3 , that is, memory, CPU, bandwidth, and the like (S220).
Thereafter, the agents determine whether the available resources at the corresponding location are larger than the resources requested for the block-off loading at the mobile terminal 30 (S230).
If it is determined that the available resources at the corresponding location are larger than the resources requested for block off loading in the
Thereafter, the agents calculate the bead values according to [Equation 1] using the estimated response time calculated (S250).
Accordingly, the F-
In step S230, if the available resources at the corresponding location are determined to be smaller than or equal to the resource requested for block-off loading in the
Next, the process of performing the block offloading process after forming the computing unit in step S260 will be described with reference to FIG.
FIG. 7 is a flowchart of a method of forming a computing unit in a mobile fog in a mobile fog computing method for performing multi-agent-based code offloading according to an embodiment of the present invention.
Referring to FIG. 7, the F-
Thereafter, the F-
Next, the base agent broadcasts a cooperation request to other agents for parallel processing of compatible basic blocks (S263).
Therefore, the agents that are not selected as the base agent determine whether parallel processing with the base agent is possible, and if possible, cooperative responses to cooperate agents, and those that do not cooperate will send a cooperative response to the base agent .
Accordingly, the base agent receives a cooperation response to the cooperation request from other agents (S264).
Thereafter, it is determined whether the number of agents capable of cooperating is more than q-1 (S265). This means that one of the q blocks offloaded is processed by the base agent and the remaining q-1 basic blocks are judged by the cooperating agents to be able to process.
If there are more than q-agents capable of cooperating, q-1 agents are selected as cooperating agents for processing q-1 off-loading blocks in order of increasing beads among agents capable of cooperating (S266).
However, if there are not more than q-1 agents capable of cooperating, i.e., less than or equal to q-1, all cooperative agents are selected as cooperative agents (S268).
The base agent forms a computing unit together with the cooperative agent selected in step S266 or the cooperative agent selected in step S267 (S267).
In this manner, when the computing unit is formed, the F-
Thereafter, the F-
While the present invention has been particularly shown and described with reference to exemplary embodiments thereof, it is to be understood that the invention is not limited to the disclosed exemplary embodiments, It belongs to the scope of right.
Claims (20)
The mobile fog selecting a base agent among a plurality of agents to process a base block offloaded from the mobile terminal; And
Wherein the base agent processes the basic block to be offloaded,
Wherein the plurality of agents manage locations for processing the offloaded basic block
Lt; RTI ID = 0.0 > fog. ≪ / RTI >
Wherein the position for processing the basic block includes:
A first location that is a location of a fog node belonging to a mobile fog to which the mobile terminal is connected;
A second location that is the location of another mobile fog adjacent the mobile fog; And
Wherein the mobile fog is located at a third location < RTI ID = 0.0 >
/ RTI >
Wherein the plurality of agents comprises:
A first agent for offloading the basic block to the first location;
A second agent for offloading the basic block to the second location;
A third agent for offloading the basic block to the third location;
A fourth agent for offloading the basic block through migration from the first location to the second location; And
A fifth agent for offloading the basic block through migration from the first location to the third location;
/ RTI >
Between selecting the base agent and processing the base block,
Selecting a cooperative agent among the plurality of agents for processing of a basic block capable of parallel processing with respect to the basic block; And
Wherein the base agent and the collaboration agent form a computing unit to process the offloaded basic block
/ RTI >
Wherein the step of selecting the base agent comprises:
Each of the plurality of agents calculating an estimated response time using resource information of a location managed by the plurality of agents;
The plurality of agents each calculating a bead value using the estimated response time; And
The mobile fog selecting the base agent using a bead value calculated for each of the plurality of agents
/ RTI >
Before each step of calculating the estimated response time,
Confirming available resources at a location managed by the plurality of agents; And
Further comprising the step of the plurality of agents comparing resources available for processing of the base block with the available resources,
The step of the agent responsible for the location of the available resources for the processing of the basic block to be offloaded calculates the estimated response time
Lt; RTI ID = 0.0 > fog. ≪ / RTI >
Wherein selecting the collaboration agent comprises:
The base agent requesting cooperation from another agent;
Receiving a collaboration response from the other agent; And
Selecting the cooperation agent among the agents capable of cooperation
/ RTI >
Wherein the selecting of the cooperative agent among the cooperative agents includes:
Determining whether the number of agents capable of cooperating is greater than the number of basic blocks to be offloaded by subtracting the number of basic blocks that can be processed by the basic agent;
If the number of agents capable of cooperating is not greater than the number of basic blocks offloaded minus the number of basic blocks that can be processed by the basic agent, ; And
If the number of agents capable of cooperating is larger than the number of basic blocks to be offloaded minus the number of basic blocks that can be processed by the base agent, Selecting as many cooperative agents as the number of basic blocks minus the number of basic blocks that can be processed by the basic agent
/ RTI >
Before offloading some of the basic blocks to mobile fog,
Dividing the mobile terminal into basic blocks through application analysis;
Collecting resource information for execution of the basic block through execution of the basic block;
Calculating a host execution time when the mobile terminal executes the basic block;
Requesting a fog execution time when the mobile fog is executed in the mobile fog while transferring resource information for execution of the basic block to the mobile fog;
Off-loading a basic block that can be off-loaded among the divided basic blocks into the mobile fog when the fog execution time transmitted from the mobile fog is smaller than the host execution time
/ RTI >
Between the step of collecting the resource information and the step of calculating the host execution time,
Further comprising comparing resources required for execution of the basic block and resources available in the mobile terminal,
Performing the step of calculating the host execution time when a resource required for execution of the basic block is larger than a resource available in the mobile terminal,
If the resource required for execution of the basic block is not more than the resources available in the mobile terminal, the mobile terminal processes the basic block
Lt; RTI ID = 0.0 > fog. ≪ / RTI >
If the estimated response time (E ij ) satisfies the following relation
Where E [N] is the estimated number of blocks on the fog node,
P K is a steady-state distribution or stationary probability of finding a K block on a queue,
Is a utilization factor,
E [Q] is the estimated queue length of the mobile fog in the second location,
L 1 is the first position, L 2 is the second position, L 3 is the third position,
L 1,2 is a communication delay between L 1 and L 2, L 1, 3 is a communication delay between L 1 and L 3,
P 0 is the probability that there is no basic block on the queue
The mobile fog computing method comprising:
The bead value (B ij ) is calculated from the following equation
Where i and j represent the location of the agent and the agent, respectively,
Is a small constant called the risk factor of the beading of the agent a i ,
Is a normalization constant.
The mobile fog computing method comprising:
Selecting a basic agent and a cooperative agent among a plurality of agents to process a basic block offloaded from the mobile terminal and forming the basic agent and the cooperative agent as a computing unit so as to distribute the off- Lt; / RTI > mobile fog,
Wherein the plurality of agents manage locations for processing the offloaded basic block
Lt; RTI ID = 0.0 > fog < / RTI >
The mobile terminal comprises:
A compiler unit for converting the high-level language of the application into a machine-understandable low-level language, and then dividing the low-level language into a plurality of basic blocks; And
Offloading for application execution using the basic blocks of the application provided by the compiler unit, and requests off-loading of the basic block to the mobile fog when off-loading is required, An application management unit receiving the execution result of the basic block
And a mobile fog computing system.
The compiler unit,
A front end for generating an intermediate code by performing a grammar and a semantic analysis on a high-level language of the application; And
Generating a byte code for the intermediate code generated by the front end, dividing the code of the low-level language into a plurality of basic blocks through independent byte code syntax and grouping the generated code, and generating a flow graph from the grouped basic block Back end
And a mobile fog computing system.
The application management unit,
An execution analyzer for collecting resource information required for execution of the basic block through execution of the application and identifying a basic block that can be offloaded at the same time; And
Determining whether the offloadable basic block identified by the execution analyzer is offloaded, and transmitting the resource information required for execution of the basic block and the basic block to the mobile fog when offloading is possible, Code offloader
And a mobile fog computing system.
Wherein the code offloader controls the off-loadable basic block to be executed where the time required for execution of the off-loadable basic block is calculated in the mobile terminal and the mobile fog.
The fog controller of the mobile fog,
Managing the plurality of agents, selecting the base agent and the cooperative agent among the plurality of agents to process a basic block offloaded from the mobile terminal, and forming the base agent and the cooperative agent as a computing unit Multi - agent part;
A code offloading unit for offloading the offloaded basic block to a corresponding location according to agent information belonging to a computing unit formed by the multi-agent unit, and controlling the offloading; And
A controller for controlling the multi-agent unit and the code off-loading unit to off-load basic blocks offloaded from the mobile terminal through the base agent and the computing unit,
And a mobile fog computing system.
Wherein the multi-agent unit calculates the estimated response time using the resource information available at the position held by the plurality of agents, and calculates the bead value corresponding to the plurality of agents using the calculated estimated response time ,
Wherein the controller selects a base agent to process the offloaded basic block and a cooperative agent to cooperate with the base agent based on the plurality of bead values for each agent
Lt; RTI ID = 0.0 > fog < / RTI >
Wherein the base agent selects the cooperative agent among agents capable of cooperating among other agents.
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
KR1020150179546 | 2015-12-15 | ||
KR20150179546 | 2015-12-15 |
Publications (2)
Publication Number | Publication Date |
---|---|
KR20170071381A true KR20170071381A (en) | 2017-06-23 |
KR101773593B1 KR101773593B1 (en) | 2017-08-31 |
Family
ID=59283587
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
KR1020150189609A KR101773593B1 (en) | 2015-12-15 | 2015-12-30 | Mobile fog computing system for performing multi-agent based code offloading and method thereof |
Country Status (1)
Country | Link |
---|---|
KR (1) | KR101773593B1 (en) |
Cited By (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
KR102177432B1 (en) * | 2019-05-29 | 2020-11-11 | 연세대학교 산학협력단 | Apparatus and method for offloading computing amount by task priority in a fog computing based wireless network |
KR20200132535A (en) * | 2019-05-17 | 2020-11-25 | 군산대학교산학협력단 | Mobile device for performing offloading process and method thereof |
KR20210064031A (en) * | 2019-11-25 | 2021-06-02 | 경희대학교 산학협력단 | Apparatus and method of constructing energy efficient communication and computation resource allocation framework for multiple communication service |
WO2023074939A1 (en) * | 2021-10-28 | 2023-05-04 | 한국전자기술연구원 | Computing offloading method based on onem2m platform |
Families Citing this family (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
KR102008786B1 (en) * | 2017-12-27 | 2019-08-08 | 인천대학교 산학협력단 | Context-Driven Mobile Learning Apparatus and method Using Fog Computing |
KR20190081323A (en) | 2017-12-29 | 2019-07-09 | (주) 유노믹 | FOGCLOUD interworking data transmission method |
KR20200068077A (en) | 2018-11-27 | 2020-06-15 | 한국전자통신연구원 | Structure and Method for Brain-inspired Hyperconnected and Distributed Intelligence |
Family Cites Families (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8566636B2 (en) | 2011-01-27 | 2013-10-22 | International Business Machines Corporation | Application recovery in a file system |
US9232433B2 (en) | 2013-12-20 | 2016-01-05 | Cisco Technology, Inc. | Dynamic coding for network traffic by fog computing node |
KR101574026B1 (en) | 2014-12-17 | 2015-12-03 | 경희대학교 산학협력단 | Internet of things using fog computing network |
-
2015
- 2015-12-30 KR KR1020150189609A patent/KR101773593B1/en active IP Right Grant
Cited By (5)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
KR20200132535A (en) * | 2019-05-17 | 2020-11-25 | 군산대학교산학협력단 | Mobile device for performing offloading process and method thereof |
KR102177432B1 (en) * | 2019-05-29 | 2020-11-11 | 연세대학교 산학협력단 | Apparatus and method for offloading computing amount by task priority in a fog computing based wireless network |
WO2020241981A1 (en) * | 2019-05-29 | 2020-12-03 | 연세대학교 산학협력단 | Device and method for offloading calculation amount according to task priority in fog computing-based wireless network |
KR20210064031A (en) * | 2019-11-25 | 2021-06-02 | 경희대학교 산학협력단 | Apparatus and method of constructing energy efficient communication and computation resource allocation framework for multiple communication service |
WO2023074939A1 (en) * | 2021-10-28 | 2023-05-04 | 한국전자기술연구원 | Computing offloading method based on onem2m platform |
Also Published As
Publication number | Publication date |
---|---|
KR101773593B1 (en) | 2017-08-31 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
KR101773593B1 (en) | Mobile fog computing system for performing multi-agent based code offloading and method thereof | |
US11503113B2 (en) | Task offloading and routing in mobile edge cloud networks | |
Liu et al. | A computation offloading algorithm based on game theory for vehicular edge networks | |
US10951521B2 (en) | Method for scheduling a computational task, a method for processing a computational task, a computer readable storage medium, a computer program, a residential gateway, and a server | |
CN108463805B (en) | User equipment selection for mobile edge computing | |
CN113261244B (en) | Network node combining MEC host and UPF selection | |
US11330511B2 (en) | Method and system for multi-access edge computing (MEC) selection and load balancing | |
US20140379928A1 (en) | Method for implementing network using distributed virtual switch, apparatus for performing the same, and network system based on distributed virtual switch | |
US20150032495A1 (en) | System and Method for User Controlled Cost Based Network and Path Selection across Multiple Networks | |
US20190045374A1 (en) | Mobile service chain placement | |
US11902108B2 (en) | Dynamic adaptive network | |
CN113316158A (en) | Method and device for deploying application instance and readable storage medium | |
CN114157667A (en) | Computing power network service system and method facing gateway equipment | |
US20240086253A1 (en) | Systems and methods for intent-based orchestration of a virtualized environment | |
JP2019506809A (en) | Virtual network function to cooperate | |
Akter et al. | Q-MAC: QoS and mobility aware optimal resource allocation for dynamic application offloading in mobile cloud computing | |
CN114930294A (en) | System, apparatus and method for edge node computation | |
Li et al. | Federated orchestration for network slicing of bandwidth and computational resource | |
CN113453252B (en) | Communication method and device | |
Chowdhury | Servant: a user service requirements, timeslot sacrifice, and triple benefit-aware resource and worker provisioning scheme for digital twin and MEC enhanced 6G networks | |
Laroui et al. | Virtual mobile edge computing based on IoT devices resources in smart cities | |
US20200322763A1 (en) | Control device configured for and method of determining a data format | |
CN113783963B (en) | Data transmission method, server node, gateway equipment and network system | |
Al-Razgan et al. | [Retracted] A Computational Offloading Method for Edge Server Computing and Resource Allocation Management | |
Sarddar et al. | A novel approach on weight based optimized routing for mobile cloud computing |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
A201 | Request for examination | ||
E902 | Notification of reason for refusal | ||
AMND | Amendment | ||
E601 | Decision to refuse application | ||
AMND | Amendment | ||
X701 | Decision to grant (after re-examination) | ||
GRNT | Written decision to grant |