Computation Resource Leasing for Priority Aggregation Local Computing Network

10/31/2019 ∙ by Chao Ren, et al. ∙ 0

In large scale smart edge networks, computation resource is generally underutilized due to the uneven distribution of computation resource in time and space domain. This may correspond to a simple fact that no device is capable for 'storing' and 'exchanging' idle computation resource. Thus, this paper proposes a computation resource leasing (CRL) concept using priority as an intermediary to restore and exchange the permission for computation resource for priority aggregation local computing network (PALCN). Each device in PALNC is able to gain priority as a reward for leasing its computing resource to others. CRL also offers a priority oriented algorithm to match the computation request with idle source nodes and a priority management model. Our analysis and numerical results show that the system can efficiently utilize local idle computation sources over time and space domain and filtrate the big task that local computation can not finish.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

I Introduction

The explosive growth is observed both in the number of mobile devices and in the amount of related computation. By the year 2020, total quantity of world-wide mobile devices would be 75 billion[1] with a traffic volume exceeding 24.3 exabytes/month, which also leads to high computation load of the same order. However, some devices are idle considering its utilization in time and space domain, e.g., smart devices plugging in charging ports, private edge IoT servers at night, and idle servers some distance away. Although there may be no urging tasks requiring computation resource, these idle devices may encounter heavy computing load in the future. Can we ‘borrow’ the idle computation resource from the past to help release some incoming heavy pressure?

Unfortunately, computation resource cannot be stored or exchanged, due to its real-time computing characteristic. Thus, we could define the aforementioned problem as uneven distribution of computation resource in time and space domain with real-time computing nature. To solve this problem, PALCN is defined to group some devices having low latency to other devices, and they are willing to share and request computation resources with high priority devices. In a PALCN, there may be idles computation resources, real-time computation tasks, future tasks, and devices sharing their computation resource for potential rewards. The uneven distribution of computation resource in time and space may be materialize into unfairness in giving and taking for devices in PALNC. Therefore, the key problem is to find a mechanism to fully utilize local resource with a new CRL concept matching real-time/future tasks with idle or semi-idle111Semi-idle means the devices that are not in full load computing e.g. computers with CPU utilization of only 30 percent devices.

To release the pressure of local computation tasks, many concepts have been applied in reality. The authors in[2]

proposed an algorithm to offload the local tasks to mobile cloud based on game theory. Reference

[3] introduced an algorithm that offload the local tasks to edge computing layer to decrease the computing energy consumption. The authors of reference[4] propose an algorithm to offload the tasks based on increasing utilization of the network. These related works are able to efficiently utilize the released computation resource from other layers to balance the uneven distribution of computation resources in space, which are also known as task offloading[5, 6, 7] or task migration[8, 9, 10]. However, in local network, task offloading or migration may not solve the resource constrains in time domain. Considering a group of local devices may cooperate and accumulate their ‘kindness’, they may have high priority to offload their future tasks to other idle or semi-idle devices cross-time. Could these devices work in a satisfying mechanism managing all the sharing, priority exchanging and restoring functions?

Thus, a new CRL concept is proposed in this paper, where the CRL member devices lease computing resource to other PALCN devices and obtain priority for their own computing. Using priority, the computation priority can be thus be accumulated, which facilitates the task offloading regardless time and space constrains, i.e., the idle computation resource restoring and exchanging problem is converted to priority accumulation and consumption problem. To match the computation tasks with idle computation within PALCN, algorithms are proposed and sort big task with matching methods. Moreover, a settlement system is proposed to manage the priority in leasing. Compared with task offloading to cloud or edge layer, CRL is able to fully utilize the local computation resource and aggregate the priority for future heavy tasks.

In summary, The distinctive feathers and contributions of this paper are as follows:

  • This paper proposes a new concept named CRL to convert the across-time invocation of the computation.

  • This paper proposes PALCN to redivide the devices in smart edge networks and is suitable for the CRL model. Finally, the conclusion is in section V.

The remainder of this paper is organized as follows. In section II. The proposed matching algorithm is described in detail in section III. Performance analyses are presented in section IV.

Notation Explanation
Deadline of the task, the unit of it is second. It describe that the computing source must finish task before
It denotes the total number of CPU cycles required to accomplish the computation task.
A constant that describe the volume of task.
A constant to describe the value of task task per bit.
The number of task.
The time that source node can compute for the task, the unit of it is second.
The value to describe the source node’s computing ability, the unit of it is bit per second
The number of the source node.
The time that task can be finished by source node.
The amount of the priority that exchange in the process of CRL.
A constant that describe the conversion rate between task value and token.
The times that CRL algorithm repeat.
The weight of of value of the task per bit.
The weight of priority.
TABLE I: Important notations.

Ii System Model

In this model, we define some devices that are logically adjacent or have time delay lower than with each other as members in a PALCN. There are some idle or semi-idle devices (provider) and some devices that need extra computation (receiver) in a PALCN (Fig. 1). The process that the provider compute for receiver is also the process in which the receiver pays the priority to the provider and the provider accumulates its priority. We call above process as CRL. When device 1 realizes the transformation from the provider at time to the receiver at time , we think that it realizes the call of computation across-time. In addition, the system should have ability to filter the big tasks that local computation source can not be finished. Thus, the system model is proposed as follows (see Fig. 1).

Fig. 1: Simplified system model : consisted of the process CRL and process filter big tasks.

We regard the CRL as process consist of matching process and priority settlement process. So we model the matching process and settlement respectively.

Ii-a Model of Matching Computation Source

Suppose there are tasks need to be computed and idle or semi-idle devices in the PALCN at one time. Regard idle devices as

computation sources with different computation ability. For every task, there are some parameters. Regard each task as a column vector, these parameters as the elements of the column vector. So a task can be expressed as (

i,i):

(1)

where the means the deadline of task . denotes the total number of CPU cycles required to accomplish the computation task. denotes the value of tasks . denotes the matching priority of task . denotes the number of task . denotes the priority that the owner of the task have.

Each tasks have different matching priority. We need to match the task in high matching priority to computing source previously. In this model, matching priority is expressed as:

(2)

where denotes the weight of value of the task per bit and its priority. The task has a higher priority means that the device of the task has completed more computation for others before.

For every computation source, there are some parameters. Regard each source as a column vector, these parameters as the elements of the column vector. So a source can be expressed as(j,j):

(3)

where denotes the time that be idle, the unit of it is second. denotes the computing ability of the source , and the unit of it is the number of CPU cycle it can finish per second. denotes the number of that source.

Make tasks to generate a 6 all tasks matrix :

(4)

Make sources to generate a 3 all source matrix:

(5)

This paper introduces priority into the model to generate the priority matrix. Rearrange the column vector of all task matrix based on in descending order. Using bubble sort to exchange column task vectors’ order to make tasks with higher priority more previous. Reorder the the subscript of all tasks and generate a new matrix named priority matrix:

(6)

The CRL process translates into matching the column vectors of priority matrix and the column vectors of all source matrix. We can regard above process as matching the appropriate provider for receiver.

The another process of system is priority settlement, it can be modeled as follow:

Ii-B Model of Priority Accumulation and Payment

Each time a CRL is completed, the priority transaction process is settled, and the receiver pays priority to the provider. We define a constant to describe the conversion rate between priority and task volume.

(7)

where denotes the weight of volume of the task and the amount of priority it own. denotes amount of priority that receiver should pay to the provider. Each time a CRL process is completed, receiver exchange priority with provider.

Iii Crl Algorithm and Priority Settlement Algorithm

The model has transform the CRL to a linear one, which make it easy to match the most preferred computation source for each task and exchange priority. Task in higher

select the resources with the more preferred to exchange priority. In this way, a positive cycle is formed. The more a device computes for other devices in a PALCN, the higher priority it have, and when it needs additional computation, it can choose resources for priority exchange previously. Tasks without resources are placed in the task matrix at the next moment to re-match resources, and the matching process is repeated

times. A task still with no resources after matches is treated as big task, and upload it to other computing layer e.g. cloud.

Iii-a CRL Algorithm

0:  
0:  
Algorithm 1 Generate the prefer matrix

After that the priority matrix shows a descending priority task order from left to right. For the task , if a idle source can finish the task on time, the need to have enough computation and can finish before the of , so it must meet(, ):

(8)
(9)
  • Case I: can finish :

    (10)
  • Case II: can not finish :

    (11)
0:  
0:  
1:  Recording the highest element in the first vector column, and set other elements in row vector as zero which means that source has been selected by the task.
2:  Recording the highest element in the second vector column, and set other elements in row vector as zero which means that source has been selected by the task.
3:  Repeat the process above.
4:  
Algorithm 2 Generate the Match matrix

For each provider, CRL can match it with a receiver to help it storage its idle computation as priority. At some time in the future, when the device needs extra computation, it can exchange the stored priority to computation from idle devices. Thus CRL realize balancing the uneven distribution of computation resources across-time. The vector column of Match matrix show the priority exchange relation between providers and receivers.

In actual use, there may be some tasks are too big to finished by local computing source, so filter them and upload to other computing layer is necessary.

0:  
0:  
1:  Recording the highest element in the first vector column, and set other elements in row vector as zero which means that source has been selected by the task.
2:  Recording the highest element in the second vector column, and set other elements in row vector as zero which means that source has been selected by the task.
3:  If all the elements in a vector column of the matrix, which means the there is no computing source can finish the task that the vector column represented. So, put that task into task list at next time.
4:  If there is still no source can finish it after repeating times, regard it as big task and upload it to cloud to finish.
Algorithm 3 Filter big tasks

If all the computing resources the task can choose cannot finish it, there are two possible remote causes

  • Case I: Its priority is too low to choose the computing resources previously.

  • Case II: There is no computing source have enough computation to finish it.

    For whatever reason, we regard it as a big task to avoid complexity of the algorithm.

Iii-B Priority Settlement

After each process of exchanging, provider and receiver both should update their priority.

0:  
0:  from i=1 to i=n = from j=1 to j=m =
Algorithm 4 Priority settlement

Priority settlement can help to exchange the priority between provider and receiver by recording the amount of the priority transaction and the priority their hold after the transaction.

Iv Numerical Results

In the following simulations, we will compare CRL with cloud offloading[2] in terms of cross-time distribution of idle computing resources , and migration data of computing tasks to measure the performance of CRL. The simulation intercepts a short period of time in CRL process. The main notations of the simulation are as follow:

=0.5 , =0.5

Iv-a Cross-Time Distribution of Idle Computation Resources

Cross-time distribution means the amount of idle computing resources changes with time. The less idle computing resources, the higher the utilization of resources in this network.

Fig. 2: Cross-Time Distribution of Idle Computation Resources

It can be seen from the simulation that CRL can reduce Cross-Time Distribution of Idle Computation Resources to improve the utilization of devices in the PALCN. Because simulation is a short period of time in the process of CRL interception, the across-time distribution of Idle Computation Resources of cloud computing changes to a constant with time. Compared with cloud computing, CRL can make full use of the resources of PALCN to compute the internal tasks in PALCN.

Iv-B Data of Computing Tasks Migration

Cloud computing will transfer all local tasks to the cloud server, which we call task migration. However, CRL will only transfer big tasks that cannot be completed locally to the cloud. We can measure the filtering effect of CRL on large tasks in PALCN by monitoring the amount of migrated tasks.

Fig. 3: Migration Data of Computing Tasks

Numerical result shows that comparing with cloud computing, CRL can reduce the amount of task migration, and with the increasing, the migration task reduced. This also shows that when the number of CRL process repetitions increases, the filtering effect for big tasks is better.

V Conclusion

In this paper, we consider the problem that unbalanced distribution of computation source across-time. We propose new concepts named PALCN and CRL to solve that problem. CRL can reduce the pressure of cloud by finishing some tasks in PALCN using local idle computation source. The most important contribution of CRL is that it realize the call of computation across-time by exchanging priority, which means realizing the storage of computation.

For the future work we are considering more general cases that expand the scope of the network, it is not limited to the PALCN, so that the devices with higher delay can also call computation resources across-time through priority exchange.

References

  • [1] “Global mobile data traffic forecast update, 2017¨c2022 white paper,” Cisco Visual Networking Index, pp. 1–33, February 2019.
  • [2] X. Chen, “Decentralized computation offloading game for mobile cloud computing,” IEEE Transactions on Parallel and Distributed Systems, vol. 26, no. 4, pp. 974–983, April 2015.
  • [3] F. Samie, V. Tsoutsouras, L. Bauer, S. Xydis, D. Soudris, and J. Henkel, “Computation offloading and resource allocation for low-power iot edge devices,” in 2016 IEEE 3rd World Forum on Internet of Things (WF-IoT), Dec 2016, pp. 7–12.
  • [4] S. Lee, H. Cheon, S. Kang, and J. Kim, “Novel lipa/sipto offloading algorithm according to the network utilization and offloading preference,” in 2014 International Conference on Information and Communication Technology Convergence (ICTC), Oct 2014, pp. 314–318.
  • [5] M. Chen and Y. Hao, “Task offloading for mobile edge computing in software defined ultra-dense network,” IEEE Journal on Selected Areas in Communications, vol. 36, no. 3, pp. 587–597, March 2018.
  • [6] Y. Zhang, J. He, and S. Guo, “Energy-efficient dynamic task offloading for energy harvesting mobile cloud computing,” in 2018 IEEE International Conference on Networking, Architecture and Storage (NAS), Oct 2018, pp. 1–4.
  • [7] A. Boukerche, S. Guan, and R. E. De Grande, “A task-centric mobile cloud-based system to enable energy-aware efficient offloading,” IEEE Transactions on Sustainable Computing, vol. 3, no. 4, pp. 248–261, Oct 2018.
  • [8]

    Y. Kong, Y. Zhang, Y. Wang, H. Chen, and X. Hei, “Energy saving strategy for task migration based on genetic algorithm,” in

    2018 International Conference on Networking and Network Applications (NaNA), Oct 2018, pp. 330–336.
  • [9] W. Zhang, S. Tan, Q. Lu, and X. Liu, “Towards a genetic algorithm based approach for task migrations,” in 2014 International Conference on Identification, Information and Knowledge in the Internet of Things, Oct 2014, pp. 182–187.
  • [10] L. Zhu, Y. Wang, W. Zhang, and S. Tan, “Cpn based validation on pervasive cloud task migration,” in 2015 IEEE 12th Intl Conf on Ubiquitous Intelligence and Computing and 2015 IEEE 12th Intl Conf on Autonomic and Trusted Computing and 2015 IEEE 15th Intl Conf on Scalable Computing and Communications and Its Associated Workshops (UIC-ATC-ScalCom), Aug 2015, pp. 986–990.