Virtualized Application Function Chaining: Maximizing the Wearable System Lifetime

04/02/2018 ∙ by Harini Kolamunna, et al. ∙ 0

The number of smart devices wear and carry by users is growing rapidly which is driven by innovative new smart wearables and interesting service o erings. This has led to applications that utilize multiple devices around the body to provide immersive environments such as mixed reality. These applications rely on a number of di erent types of functions such as sensing, communication and various types of processing, that require considerable resources. Thus one of the major challenges in supporting of these applications is dependent on the battery lifetime of the devices that provide the necessary functionality. The battery lifetime can be extended by either incorporating a battery with larger capacity and/or by utilizing the available resources e ciently. However, the increases in battery capacity are not keeping up with the demand and larger batteries add to both the weight and size of the device. Thus, the focus of this paper is to improve the battery e ciency through intelligent resources utilization. We show that, when the same resource is available on multiple devices that form part of the wearable system, and or is in close proximity, it is possible consider them as a resource pool and further utilize them intelligently to improve the system lifetime. Speci cally, we formulate the function allocation algorithm as a Mixed Integer Linear Programming (MILP) optimization problem and propose an e cient heuristic solution. The experimental data driven simulation results show that approximately 40-50 system battery life improvement can be achieved with proper function allocation and orchestration.

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.

1. Introduction

Interest and popularity of mobile and wearable devices is persistent and is increasing due to the variety of attractive applications and services provided on top of them. Mixed Reality is expected to drive the future demand as they utilize advanced capabilities of the smart wearables and hand-held devices that allows users to interact with immersive virtual environments with real objects (Costanza et al., 2009). On the other hand, many novel services including mixed reality are extremely resource hungry as much as revolutionary.

These applications continuously use three types of functions, namely sensing, processing and communication. Each function in these broader categories can be considered as ‘application functions’, as they are utilized during the runtime of the applications. These application functions requires a considerable amount of system resources such as energy, computation, and memory. Among these, energy has been identified as the most challenging, as the battery technology is not keeping pace with growth in demand. As a result, the life time of current resource heavy wearable applications that rely on wearable devices cannot be used for long periods of time (Williamson et al., 2015; Seneviratne et al., 2017).

Today, most users own more than one wearable device. According to Cisco, average devices and connections per capita in North America will rise to 12.9 by 2021 (Cisco, 2017)

. These devices can be classified as either a Tier 1 or a Tier 2 device depending on their functional capabilities that also reflects the resources they posses

(Kolamunna et al., 2016). Tier 1 devices, e.g. smartphone, smartwatch and smartglasses, are more resourceful than the Tier 2 devices and have the capability of performing all three types of the functions that many applications require, namely sensing, processing, and communication (short-range and long-range). On the other hand, Tier 2 devices, e.g. heart-rate sensor, smart-sole, etc. basically perform sensing functionality and has short-range communication. They are generally paired with a Tier 1 device. These devices are already interconnected and form a personal area network on user’s body (PAN). Many devices on a PAN replicate the three types of functions mentioned above. Therefore, as the devices in a PAN are interconnected, it is possible to consider them as providing a pool of functional capabilities that are distributed and often replicated in multiple of the devices.

This open us the possibility of utilizing capabilities across devices on a PAN. However, the current system implementations limits the accessibility of resources on the other devices. Methods of overcoming these limitations and allowing seamless access to the resources on a PAN and in close proximity has been proposed (Kolamunna et al., 2016; Vallina-Rodriguez and Crowcroft, 2011; Hemminki et al., 2013; Oh et al., 2017). These approaches allow the functions to be implemented and the user/application to access them without considering the exact location of the function. To fully leverage the distributed resources, the sequences of functions (function chains) execution needs to be guaranteed, to achieve the correct Functionality. Therefore, the challenge is to determine the criteria for the selection of the path of the function chain, and how does this dynamic function chaining can be implemented where the functions are virtualised to enable seamless accessibility similar to network function orchestration in software defined networks (Bari et al., 2015; Blendin et al., 2014). This requires the design of an optimal application function orchestration algorithms. This paper shows that optimal application function orchestration is NP-hard, but that it possible to achieve near optimal function orchestration using a heuristic algorithm that finds the best function allocation by considering the function chaining in order to maximize the system lifetime, and make the following contributions.

  • Define design goals for the wearable system energy resource management considering the current trends in wearable devices as well as surveying diverse set of users to understand user expectations.

  • Formulate the function allocation problem in wearable systems as a Mixed Integer Liner Programming (MILP) optimization to maximize the wearable system lifetime whilst satisfying all functional requirements.

  • Derive the linear programming approximation factor and show the requirement of efficient heuristic algorithm under practical constraints, which is followed by an efficient heuristic algorithm incorporating function orchestration.

  • Demonstrate the feasibility of implementing the proposed heuristic algorithm on real devices by measuring and comparing the computational time on a smartphone and a smartwatch.

  • Evaluate the proposed heuristic solution accuracy, efficiency, and robustness, against the currently used function allocation methods and methods proposed in the literature by conducting experimental data driven simulations. The results show that dynamic function allocation increases the system lifetime by approximately 50% compared to the existing common non-collaborative function allocation methods and 40% compared to the collaborative function allocation methods proposed in the literature.

The rest of this paper is organized as follows. We first overview the related work and complementary systems. Next in Section 3, we present the function allocation problem formulation followed by efficient algorithms for function allocation including function orchestration in Section 4. In Section 5, we evaluate the proposed algorithms and also the feasibility of increasing wearable system lifetime with experimental driven simulations. Finally, we provide the conclusions in Section 6.

2. Related Work

The concept of application function virtualization (AFV) is an extension and generalization of the concept of network function virtualisation (NFV). As in the case with NFV, one of the challenges is the the chaining of the functions (service function chaining - SFC) to achieve the dual objectives of providing the required services, and maximizing the service lifetime.

NFV enables the functions that are provided by proprietary hardware and software to being able run on open hardware, thus reducing the capital and operational expenditure. However, to provide specific network service in an NFV enabled network, requires the traffic to traverse multiple of the virtualized function instances in a defined order. Unlike in the hardware implementation of the network functions, the virtualization of the functions makes this too complex and inefficient (Kuo et al., 2016). More specifically, the virtualized functions are topology dependent and difficulties occurs during the configuration (Quinn and Nadeau, 2015). Therefore, much attention has been paid to developing mechanisms for chaining virtualized functions or orchestration by both the research community and standardization authorities (Halpern and Pignataro, 2015; Bari et al., 2015).

In order to perform function chaining, it is required to have knowledge about the available services via the virtualized function instances and their reachability. There are several approaches available for SFC that extends the currently available methods (John et al., 2013; Sun et al., 2012). The architectural designs proposed by the standardizing authorities (ETSI, 2014; Halpern and Pignataro, 2015) build on top of the basic NFV architectures proposed by (ETSI, 2014). Similarly, in our design, we build our function chaining architecture on top of the proposed application function virtualization architecture (AFV) in (Kolamunna et al., 2016) and extend it to incorporate function chaining. These architectural designs for function chaining have the following approaches; 1) having a separate management system to orchestrate the function chaining (ETSI, 2014; Li and Chen, 2015), which allows the control plane to have the overview of the availability of function instances and how they can be accessed, and 2) allowing the data packets to carry the controlling signals within its header (Halpern and Pignataro, 2015; Quinn et al., 2017).

Our design combines both the approaches but generalizes it to be used with application function virtualization requirements, which leads to different objectives such as energy minimization (Kim and Feamster, 2013), optimal utilization of the resources (Sahhaf et al., 2015; Riera et al., 2014; Mehraghdam et al., 2014), minimization of latency (Bhamare et al., 2015; Moens and Turck, 2014), minimizing the monetary cost (Bouet et al., 2015), etc. None of these proposed schemes consider application function virtulalization and attempts to combine the different objectives to maximize the system lifetime.

3. Problem Formulation

Figure 1. An overview of an personal area network.

Despite the increasing trend in wearing and carrying multiple personal devices, there is an significant overlap in primary functionality they provide such as sensing, processing and communication, especially among the Tier 1 devices. In the example PAN in Figure 1, all three Tier 1 devices (i.e., smartwatch, smartphone and smartglasses) can perform GPS location sensing, step counting and provide Internet access. However, each device is likely to have specific use cases (i.e., fitness tracking, navigation and video streaming), which combine and use these primary functions in different orders. Our hypothesis is that if the devices on the same PAN collaborate with each other to harness the power of common functions, it is possible to provide better utility to the user. In this paper, we focus on the wearable system lifetime as the utility objective, although it can be other objectives such as new services, information quality and/or information fidelity/precision.

Wearable system lifetime can be defined in multiple ways as per individual user requirements: i) All devices to be useable for the longest period of time, ii) At least one device to be useable and iii) The preferred device to be useable for the longest period of time. Therefore, we first conducted a user study to understand user requirements in terms of lifetime of devices on a PAN.

3.1. User study: Wearable system lifetime

We collected responses from 70 users who uses more than one wearable or a hand-held device. These users belonged to different age groups (20-60 years) and come from different backgrounds (e.g. Healthcare, Education, Technology, Student, Sales/Service, etc.).

Figure 2. User preference in wearable system lifetime.

According to our survey results (Figure 2), overwhelming majority voted for the preferred device to be useable for the longest period of time. Further analyses of user comments showed that it is more about their preferred functionality, instead of their preferred device. However, the availability of the user preferred functionalities are replicated in todays Tier 1 devices, and even some applications are designed to incorporate the functionalities of other devices as well (e.g. mixed reality applications). In light of these user responses, we define the wearable system lifetime as the battery life of Tier 1 devices on the PAN. This is followed by our problem statement how to maximise the battery life of Tier 1 devices whilst satisfying all functional requirements.

3.2. Function Allocation Problem

Thus the objective is to allocate each function request from each device to function implementations in different devices in the correct order whilst maximizing the system lifetime. In other words, for each instance, it is required to maximize the lifetime of the Tier 1 device on the PAN with the lowest battery life. We define the lifetime of a device as the ratio between the remaining energy () and expected energy usage which is defined as the sum of current usage () and the energy usage of newly assigned functions (). We then formulate the function allocation problem as a Mixed Integer Liner Programming (MILP) problem in Equation 1. Table 1 summarises the definitions for all the symbols used in this section.

(1)

Such that:

depends on the energy consumption of each function, Function Cost and the energy consumption for the data transfer in between two devices (Communication Cost), if the function is allocated to another device. Communication cost consists of two parts, i.e. data transferring cost, and idle cost. The data transferring cost can be either due to data transmission from/to a function invocation in device to the request in device (), or the data transmission from/to the function in device to the device (). The idle cost in device () is due to the waiting time before closing the connection.

The first constraint shows that the execution of a function or an assignment of a function request can only be ‘yes’ or ‘no’ [0/1]. Specifically, if the function is executing in device , if the request for the function from device () is assigned to device , if the request for the virtual function from device is assigned to device , and if the idle communication energy is considered. Secondly, the communication costs are zero if the function invocation device and the requesting device are the same. Third constraint expresses that the request is mapped to device only if the function is available in the device . The forth constraint expresses that each of the requests is assigned exactly to one of the devices that has the function. Next constraint shows that if the communication cost is considered for a particular communication in between device and , both the devices need to consider the costs. The constraint 6 shows that a function will invoke only if any of the requests are assigned to the function in the device. Next, if any communication is happening, the idle communication is to be considered. Finally, if there are any requirements for any of the devices to be alive for a certain time, that requirement is to be satisfied.

In this problem formulation, the objective function and the constraints always have a linear relationship with each of its variables. However, some variables in this problem formulation has to have binary values. As an example, the assignment of a function to a request is either true(1) or false(0). Therefore, this problem formulation is equivalent to Mixed Integer Liner Programming (MILP) problem.

Symbol Definition
- Set of devices in PAN
- Set of functions in device
- Set of requests made from device
- Interval in between two executions of the algorithm
- Implementation energy of a function per time units
- Energy of per time units communication for the request for the function from device () that is made to device (receiving energy excluding the idle cost). if
- Energy of per time units communication for the request made from device to the virtual function (transmission energy excluding the idle cost). if
- Idle energy for device
- lifetime of in time units
- Expected minimum lifetime of in time units
- Remaining energy of
- Energy usage of with in time units
- Current energy usage of with in time units
- Assigning energy usage of with in time units
Table 1. Definitions of Notations

4. Function Allocation Algorithm

Solutions to MILP problems are known to be NP-hard (Grötschel, 2006) and the potential approaches can be broadly categorised into: i) Exact Algorithms that guarantee to find an optimal solution, but may take an exponential number of iterations; ii) Approximation Algorithms that provide sub optimal solutions in polynomial time, and provides a bound on the degree of sub optimality; and iii) Heuristic Algorithms that provide sub optimal solutions, but do not guarantee the quality of the solutions, and do not guarantee the polynomial time solutions.

4.1. Exact Algorithms

Even though the exact methods assure the optimal solutions, the complexity grows exponentially. However, these methods in the case of AFV chaining can be used where the number of devices and the functions are very low. The mostly used two exact solution methods (brute force search and branch and bound (Dupont, 2008)) are shown in the Appendix A and Appendix B respectively, with the specific solutions and their respective computational complexities.

4.2. Linear Programming (LP) Approximations

However, when the number of devices and available functions increase, the use of exact methods become impractical due to the increase in computational complexity. Therefore, the general practice is to use approximation methods. Most of these methods are based on linear programming. In these methods, the integer constrains in the original MILP problem are replaced with the linear constrains to solve the LP problem. With these methods, optimal solutions can be obtained in polynomial time and lead to the lower bound of the original MILP problem solutions. If any variable that is to be an integer variable in the original problem is a non-integer in the LP relaxation solutions, these values are rounded to the nearest integer. The rounding in these integral solutions lead to sub-optimal solutions. A greedy method is required to find the integral solutions without significantly increasing the cost. The approximation factor is defined as the ratio in between integral solution and the lower bound. For the LP representation, the constraints of the function allocation problem defined in Equation 1 should be changed as follows.

From the solutions to the LP approximation, we get a solution for the system lifetime, i.e. the lifetime of the device that is the minimum among the other devices. The optimal solutions for LP approximation () is called the lower bound of the solutions to MILP problem. The equation 2 shows the lower bound calculation.

(2)

Integral Solution: However, the optimal solution to the LP approximation does not guarantee a integral solution. Therefore, we need to obtain the integral solution from the solution. Greedy methods or certain rules sets leads to the integral solution. The below mentioned are the rules that we define in order to find the integral solution.

  • If any request from is not 100% assigned to any one of the other devices in the solutions, it should be assigned to itself.

    • If

    • & & ;

  • If any percentage of any of the requests from other devices is assigned to , that means the requests can not be fulfilled by any of the other devices. Because, if it is possible, these will not be added to the device that increases the cost.

    • If ;

    • &

In the worst case, all the requests from the device is to be fulfilled by the device itself. In addition, all the requests from other devices that has the [self-functioning cost communication cost] is to be run in the device . Hence, the cost for the worst case integer solution () is calculated as in equation 3.

(3)

In the best case for the optimal solution () for OPT(LP), all the requests from device would be fully allocated in a way that ensures the minimum cost to . Then, none of the requests from any of the other devices are allocated to .

(4)

Approximation Factor: The approximation factor (AF) for a minimization problem is defined as the ratio of the cost of integral solution to the cost of LP optimal solution (Guo and Shen, 2017). We considered the worst case integral solution for the AF calculation. The AF is calculated as in equation 5.

(5)

The AF for a minimization problem is always greater than 1. However, this method of AF calculation depends on the variable values and sometimes it would give a huge value. Therefore, LP approximation method is unsuccessful of dealing with hard capacities as in this problem. Also, the linear programming representation of this specific problem suffers from another aspect that is the increment of the number of variables as the number of function types and devices are increased.

4.3. Heuristic Algorithms

As explained earlier, heuristic methods neither guarantee the solutions with polynomial time complexities, nor the optimality of the solution. Therefore, the design of the heuristic methods have to crafted to give a nearly optimal solution without increasing the computational complexity significantly.

Table 2 shows the energy usage for time units for all the possible requests to functionality mappings. The first column shows the available functionalities [] (i.e., the function in device ). The second column shows the functionality cost of the function . The cell entries of this column is a series of cost values, where each value in this series is the cost for each device in the network. However, only the device will have the cost in a particular series and the cost for all the other devices are zero.

The columns from column 3 show the communication cost for the functionality assignment for the requests , where the request is coming from the device for the function . Similar to other columns, the cell entries in each column is a series of cost values, where each value in this series is the cost of communication for each device in the network. If the requesting device and the functioning device are different, both devices have the communication cost. On the other hand, if the request is assigned to the same device, the communication cost is zero. If the devices that is neither the requesting nor the functioning device, the communication cost is again zero. The values for , , and for each device are fed to the algorithm. The values for and do not change over the iterations for one solution search. However, and would change their values depending on the selection of functions and the requests during each iteration.

. . . .
(,…,) (,…,)
. . . .
. . . . . . . .
. . . .
(,…,) (,…,)
Table 2. Energy usage for time units. (energy usage in ,…,energy usage in )
Input:
Output: assignment
; repeat
      Select and s.t. that minimize ;
     
     
     
     
      ) ) ( )
      until ;
ALGORITHM 1 Function Allocation Algorithm

The algorithm runs for each type of function separately as a particular function request can only be satisfied with the invocation of the same type of function. The algorithm works as follows for a particular function type , and described in Algorithm 1. The system lifetime is calculated as in (6). Let’s assume that is the initial system lifetime that is calculated without assigning the requests. First, we select a function () and a set of requests that minimizes the system lifetime reduction from the earlier system lifetime. And once the function and the set of requests are selected, the set of requests are assigned to the function and remove from further considerations. However, the function is still considered with the functioning cost of zero, as it is already executing for the assigned requests. Then the current energy usage for the devices are reassigned with the cost . Then, the is replaced by the value , where indicates whether the device is involved in communication with any of the other devices.

(6)

4.4. Virtualized Function Chaining in faa

In the previous section, we show how the the proposed heuristic method of faa runs for each type of functions separately and assigns these functions optimally. In this section, we show the incorporation of function chaining in faa in order to find the optimal path of the function chain.

Each of the real world application has its own sequence of functions (cf. Figure 1). In this figure, the sequence number ‘’ is labeled for each of the function in each application. One device may have multiple of the applications running at a particular time. Therefore, a particular sequence of functions is defined for each application ‘’ in device ‘’. Therefore, each request has its unique Request ID ().

At first, all the types of function requests that has the sequence number are considered. Next, the faa is performed for each of the function type and finds the best allocation for each type. Then it considers the functions in the ascending order of the sequence number. In order to maintain function chaining, a log is maintained as the faa is performed. This log contains chain identification (), sequence number (), function type (), function requesting device (), function performing device (). After performing faa for all function types for a particular value, the faa then starts allocating functions to the requests that are next in the sequence (). At this point, the faa does not consider that these requests are coming from the original requesting devices, but they are considered as coming from the devices where the previous request in the chain is allocated to.

5. Evaluation

We first present the performance analysis of faa in terms of accuracy, efficiency, and robustness. Next, we evaluate the wearable system lifetime improvement using virtualized function chaining with an use case scenario that is emulated with an experimentally measured energy consumption values.

5.1. Performance analysis of faa

5.1.1. Simulation setup

For this analysis, we consider a wearable system with three devices, where each device is installed with the proposed virtualized function chaining modules. Each function chain is simulated to have the same number of functions that is gradually increased up to ten functions per device. We consider every function is of different type and the energy consumption of each function (Function Cost

) is normally distributed with average

of 200mJ per minute, and the standard deviation of (

) such that . We consider that each function uses 13.5KB of data per minute (i.e. a typical amount of data generated from a sensing function per minute (Kolamunna et al., 2016)) that needs to be transferred to the next function in the chain once in every minute. We consider that the three devices have 400mAh, 450mAh, and 500mAh battery capacities (i.e. available smart wearable devices’ normal battery capacity 111https://www.gsmarena.com), and each of the experiment starts with 100% of battery charge in all the devices.

The energy consumption for the data transfer in between two devices (Communication Cost) consists of two parts, i.e. data transferring cost, and idle cost that is caused due to the waiting time before closing the connection. In general, the idle cost is almost 80% from the Communication Cost during Bluetooth transmission of 10KB of data. The Communication Cost for a function is as same as the average Function Cost (200mJ per minute). However, we consider that all the communication in between devices (10KB of data for each function) is performed once per minute, and all at once. Therefore, the idle cost is shared among the number of functions in the chain. Hence, as the number of functions in the function chain is increased, the Communication Cost per function is decreased.

We then compare the system lifetime (i.e. time until all the Tier 1 devices are ’ON’) increment of (faa) against the following;

  • OPTIMAL - The optimal solution for every faa instance obtained from the brute force method.

  • MANUAL - A random selection of one device in the wearable system to execute each function request. This method is analogous to asking the user to select function allocation.

  • EACH - Every device in the wearable system perform all functions independently which is the usual practice with current cross device wearable applications.

  • - The most related function allocation algorithm proposed in the literature (Kolamunna et al., 2016). However, this work does not consider function chaining. Therefore, we modified to incorporate function chaining as described in Section 4.4.

5.1.2. Accuracy, Efficiency and Robustness of faa

We measure the percentage increment of the system lifetime when using faa (Algorithm 1) compared to the four existing approaches. Figure 3(a) shows the percentage system lifetime increment by using faa when the number of functions in the function chain is increased. As being a heuristic solution method, faa provides a suboptimal solution. However, the error of this heuristic solution to the OPTIMAL solution is minimal where it has less than 5% average error even when the number of functions in the chain is 10. On the other hand, the system uptime increment becomes much significant compared to MANUAL, EACH, and , as the length of the function chain is increased. This is due to that the faa optimizes the allocation of more functions when the length of the chain is increased. This behavior is even applicable when the number of function chains are increased, where more function requests are optimized by faa. In particular, faa improves system lifetime approximately 50% compared to non-collaborative function allocation such as MANUAL and EACH methods and improves by 40% compared to collaborative function allocation such as .

(a) The impact of no. of functions for the optimality of faa algorithm.
(b) Algorithm execution time.
(c) Use case 1
Figure 3. Accuracy, Efficiency and Robustness of faa Algorithm

As mentioned in Section 4.3, the heuristic methods of solutions for the MILP problems does not guarantee the efficient solution methods. Therefore, we measure the computation time for the faa algorithm as a measure for the efficiency of the algorithm, and the results are shown in Figure 3(b). Also, we compared the computation time with the . Both of these algorithms were developed in Android as wearable/mobile applications and measured the time usage of calculations. We use Nexus5 as the smartphone example and LG Watch Urbane as smartwatch example. As per the results, even when the number of functions per device is 10, faa provides near optimal solutions within 1 second (note the log axes), where the exact method (brute force search) takes few hours to calculate the optimal solution. Moreover, the faa algorithm execution time is comparable with the algorithm execution time of , but provides higher quality solutions than .

As per the above results, a PAN consists of three devices and when the number of functions per device is changed from 1 to 10, a minimal error with the optimal solution is maintained by the faa algorithm (cf. Figure 3(a)). Also, these sub optimal results are provided within 1 second for all the values of the number of functions (cf. Figure 3(b)). These results express the robustness of the proposed faa algorithm for realistic use case scenarios.

5.1.3. Emulating multiple use case scenarios

Function Energy cost
Phone Watch Glasses
Connectivity (Data Transferring [mW] - Idle [mJ])
Bluetooth 520 - 605 180 - 190.3 164 - 191.85
WiFi 790 - 66 480 - 50 460 - 52
Processing [mW]
Encoding 1400 860 900
Sensing [mW]
Accelerometer-FASTEST 77.7 164 153.4
Video Capturing (LiKamWa et al., 2014) - - 2963
GPS Location (Carroll and Heiser, 2010) 166 148 155
Step Count - 5 -
Table 3. Energy cost associated to each function

Next, a use case scenario with real energy cost values is emulated and present the accuracy and robustness of faa. We consider a PAN that consists of two devices (smartphone and smartwatch), and applications installed in each of the device request accelerometer data in FASTEST speed for the indoor navigation. The application updates in every 30 seconds, and therefore, the data is processed by the applications in every 30 seconds. We modelled this scenario as two requests for the function of ‘accelerator data in FASTEST speed’ are made by two devices in the PAN that required to receive data in every 30 seconds. The power requirement specified in Table 3 are used for the calculations and the smartphone and smartwatch have 2300mAh and 410mAh battery capacities respectively.

We implemented faa and also the algorithm proposed in (Kolamunna et al., 2016). Figure 3(c) shows the system lifetime increment of using each faa algorithm, compared to different methods of existing function allocation, i.e. EACH and MANUAL (smartphone/ smartwatch). The initial battery percentage of the smartphone is changed along with the experiment, providing different use case scenarios. As per the results, faa algorithm always selects the optimal function allocation at all the values of initial phone battery percentages. However, is not always being the optimal, as the selection of decreases the system lifetime compared to some of the common function allocation method (EACH, MANUAL) for certain initial phone battery conditions. The results show that the faa provides accurate results at each different status of the devices at the beginning of the experiment, i.e. different levels of initial battery status.

5.2. Evaluation with real world scenarios

We consider a real world scenario that consists of five devices as shown in Figure 1 and they are already inter connected. It has three Tier 1 devices (smartphone, smartwatch, smartglasses), one Tier 2 device (smart-sole) that has the GPS sensing capability, and also a (laptop computer) that has the highest computational capabilities. However, the laptop computer is not always attached with the user, and therefore, we refer to it as an extended PAN device. Resource hungry gaming application in the smartglasses involves in video streaming. It captures the video of the surrounding, adds the GPS location data, encrypts data and streams to another external party. The smartwatch is running a fitness tracking application that requires GPS location and step count at the same time. Also, a navigation application is running in the smartphone that requires GPS location. Here, the user/developer has specified preferences to run the ‘Capture Video’ function in the smartglasses, and the ‘Step Count’ function in the smartwatch. Therefore, these two functions are assigned accordingly at the beginning of the faa. The remaining function requests are allocated as per the faa. The specified energy values in Table 3 is used to emulate the real world scenarios. The smartphone, smartwatch and smartglasses has 2300mAh, 410mAh and 570mAh battery capacities respectively. In order to calculate the default energy usage, we consider the smartphone can retain for 2 days with the default energy drainage, smartwatch and smartglasses retain one day. These were obtained from the specifications for real devices.

Figure 4 shows the percentage of system lifetime increment compared to the current default method of function allocation (i.e. the device itself is performing all the functions), against the availability of the Tier 2 device (smart-soles) and the extended PAN device (laptop computer). When the tier 2 device and the extended PAN device are available for a longer time period, the system uptime increment inclines. However, after a certain time, the system lifetime can not be further increased, and that is where each graph is plateaued. This is because that, even all the processing and sensing are fully allocated to the laptop computer and the smart-sole, while allocating the minimum possible amount of workload to the Tier 1 devices, the Tier 1 devices will get their batteries drained out and limit the further increment of the system lifetime.

Moreover, same as in Section 5.1.2, it can be observed that the percentage system lifetime increment is much more significant compared to the default function allocation when the length of the function chain is increased. Also, the faa algorithm proposed in this paper outperforms the at each scenario of availability of the devices.

Figure 4. Function Chaining.

6. Conclusion

Smart wearable devices is increasing exponentially and are becoming pervasive. We are also witnessing a wide variety of fascinating new applications and services, such as mixed reality, that leverage the capabilities of these wearables, but also massively resource hungry. However, one of the major constraints of wearables is the battery capacity, and as a result, this leads to poor user experience as the application lifetimes become limited. Moreover, the current non-efficient resources utilization exacerbates this problem. It is clear that one of the most practical solutions to the problem is to leverage the resources of multiple devices on the personal area network. However, this requires efficient coordination of the pool of resources that are available and the orchestration of their use.

To the best of our knowledge, this paper presented the first proposal for application function orchestration, and showed that it is possible to maximize the overall wearable system lifetime using a heuristic algorithm of function allocation. The percentage system lifetime increases with the length and the number of function chains as it increases the number of optimized function allocations. For a particular use case of 3 devices and 10 function types, the proposed heuristic method of function allocation increases the system lifetime by 50% compared to the existing common non-collaborative function allocation methods, i.e. manual allocation and allocation to all devices, and by 40% compared to the most related collaborative function allocation method proposed in the literature. However, the heuristic solution methods used in the proposed algorithm maintains a minimal error with the optimal solutions while providing a significant improvements in the time complexity and efficiency. We also demonstrated the practical feasibility of executing the proposed algorithm on real devices in near real time by implementing it on a smartphone and a smartwatch.

In our future work, we intend to extend our implementation to develop a cross-device function allocation framework that can be utilized by application developers to take advantage of the power of common functionalities available on the PAN.

References

  • (1)
  • Bari et al. (2015) Md. Faizul Bari, Shihabur Rahman Chowdhury, Reaz Ahmed, and Raouf Boutaba. 2015. On Orchestrating Virtual Network Functions. In Proceedings of the 2015 11th International Conference on Network and Service Management (CNSM) (CNSM ’15). IEEE Computer Society, Washington, DC, USA, 50–56. https://doi.org/10.1109/CNSM.2015.7367338
  • Bhamare et al. (2015) Deval Bhamare, Mohan Krishnamoorthy, and Ashwin Gumaste. 2015. Models and algorithms for centralized control planes to optimize control traffic overhead. Computer Communications 70, Supplement C (2015), 68 – 78. https://doi.org/10.1016/j.comcom.2015.06.022
  • Blendin et al. (2014) J. Blendin, J. Rückert, N. Leymann, G. Schyguda, and D. Hausheer. 2014. Position Paper: Software-Defined Network Service Chaining. In 2014 Third European Workshop on Software Defined Networks. 109–114. https://doi.org/10.1109/EWSDN.2014.14
  • Bouet et al. (2015) M. Bouet, J. Leguay, and V. Conan. 2015. Cost-based placement of vDPI functions in NFV infrastructures. In Proceedings of the 2015 1st IEEE Conference on Network Softwarization (NetSoft). 1–9. https://doi.org/10.1109/NETSOFT.2015.7116121
  • Carroll and Heiser (2010) Aaron Carroll and Gernot Heiser. 2010. An analysis of power consumption in a smartphone. Proceedings of the 2010 USENIX conference on USENIX annual technical conference (2010), 21–21. https://doi.org/10.1145/1375527.1375575 arXiv:978-1-4503-1223-3/12/04
  • Cisco (2017) Cisco. 2017. The Zettabyte Era: Trends and Analysis. Online. (June 2017). https://www.cisco.com/c/en/us/solutions/collateral/service-provider/visual-networking-index-vni/vni-hyperconnectivity-wp.pdf
  • Costanza et al. (2009) Enrico Costanza, Andreas Kunz, and Morten Fjeld. 2009. Human Machine Interaction. Springer-Verlag, Berlin, Heidelberg, Chapter Mixed Reality: A Survey, 47–68. https://doi.org/10.1007/978-3-642-00437-7_3
  • Dupont (2008) Lionel Dupont. 2008. Branch and bound algorithm for a facility location problem with concave site dependent costs. International Journal of Production Economics 112, 1 (2008), 245–254. https://doi.org/10.1016/j.ijpe.2007.04.001
  • ETSI (2014) ETSI. 2014. Network Functions Virtualisation (NFV); Architectural Framework. ETSI GS NFV 002 v1.2.1 1 (2014), 1–21. https://doi.org/DGS/NFV-0011
  • Grötschel (2006) Martin Grötschel. 2006. Primal Heuristics for Mixed Integer Programs. Informationstechnik September (2006).
  • Guo and Shen (2017) L. Guo and H. Shen. 2017. Efficient Approximation Algorithms for the Bounded Flexible Scheduling Problem in Clouds. IEEE Transactions on Parallel and Distributed Systems 28, 12 (Dec 2017), 3511–3520. https://doi.org/10.1109/TPDS.2017.2731843
  • Halpern and Pignataro (2015) J. Halpern and C. Pignataro. 2015. Service Function Chaining (SFC) Architecture. IETF RFC, 7665 (2015).
  • Hemminki et al. (2013) Samuli Hemminki, Kai Zhao, Aaron Yi Ding, Martti Rannanjärvi, Sasu Tarkoma, and Petteri Nurmi. 2013. CoSense: A Collaborative Sensing Platform for Mobile Devices. In SenSys. Rome, Italy, 34–35. https://doi.org/10.1145/2517351.2517402
  • John et al. (2013) W. John, K. Pentikousis, G. Agapiou, E. Jacob, M. Kind, A. Manzalini, F. Risso, D. Staessens, R. Steinert, and C. Meirosu. 2013. Research Directions in Network Service Chaining. In 2013 IEEE SDN for Future Networks and Services (SDN4FNS). 1–7. https://doi.org/10.1109/SDN4FNS.2013.6702549
  • Kim and Feamster (2013) H. Kim and N. Feamster. 2013. Improving network management with software defined networking. IEEE Communications Magazine 51, 2 (February 2013), 114–119. https://doi.org/10.1109/MCOM.2013.6461195
  • Kolamunna et al. (2016) Harini Kolamunna, Yining Hu, Diego Perino, Kanchana Thilakarathna, Dwight Makaroff, and Aruna Seneveratne. 2016. AFV : Enabling Application Function Virtualization and Scheduling in Wearable Networks. In UbiComp ’16: Proceedings of the 2016 ACM International Joint Conference on Pervasive and Ubiquitous Computing. Heidelberg, Germany, 981–991.
  • Kuo et al. (2016) T. W. Kuo, B. H. Liou, K. C. J. Lin, and M. J. Tsai. 2016. Deploying chains of virtual network functions: On the relation between link and server usage. In IEEE INFOCOM 2016 - The 35th Annual IEEE International Conference on Computer Communications. 1–9. https://doi.org/10.1109/INFOCOM.2016.7524565
  • Li and Chen (2015) Yong Li and Min Chen. 2015. Software-defined network function virtualization: A survey. IEEE Access 3 (2015), 2542–2553. https://doi.org/10.1109/ACCESS.2015.2499271
  • LiKamWa et al. (2014) Robert LiKamWa, Zhen Wang, Aaron Carroll, Felix Xiaozhu Lin, and Lin Zhong. 2014. Draining our Glass: An Energy and Heat Characterization of Google Glass. (2014). https://doi.org/10.1145/2637166.2637230 arXiv:1404.1320
  • Mehraghdam et al. (2014) S. Mehraghdam, M. Keller, and H. Karl. 2014. Specifying and placing chains of virtual network functions. In 2014 IEEE 3rd International Conference on Cloud Networking (CloudNet). 7–13. https://doi.org/10.1109/CloudNet.2014.6968961
  • Moens and Turck (2014) H. Moens and F. D. Turck. 2014. VNF-P: A model for efficient placement of virtualized network functions. In 10th International Conference on Network and Service Management (CNSM) and Workshop. 418–423. https://doi.org/10.1109/CNSM.2014.7014205
  • Oh et al. (2017) Sanguen Oh, Hyuck Yoo, Dae R. Jeong, Duc Hoang Bui, and Insik Shin. 2017. Mobile Plus: Multi-device Mobile Platform for Cross-device Functionality Sharing. In Proceedings of the 15th Annual International Conference on Mobile Systems, Applications, and Services. New York, NY, 332–344. https://doi.org/10.1145/3081333.3081348
  • Quinn et al. (2017) Paul Quinn, Uri Elzur, and Carlos Pignataro. 2017. Network Service Header (NSH). Internet-Draft draft-ietf-sfc-nsh-28. Internet Engineering Task Force. https://datatracker.ietf.org/doc/html/draft-ietf-sfc-nsh-28 Work in Progress.
  • Quinn and Nadeau (2015) P. Quinn and T. Nadeau. 2015. Problem statement for service function chaining. IETF RFC, 7498 (2015).
  • Riera et al. (2014) J. F. Riera, X. Hesselbach, E. Escalona, J. A. García-Espín, and E. Grasa. 2014. On the complex scheduling formulation of virtual network functions over optical networks. In 2014 16th International Conference on Transparent Optical Networks (ICTON). 1–5. https://doi.org/10.1109/ICTON.2014.6876564
  • Sahhaf et al. (2015) Sahel Sahhaf, Wouter Tavernier, Matthias Rost, Stefan Schmid, Didier Colle, Mario Pickavet, and Piet Demeester. 2015. Network service chaining with optimized network function embedding supporting service decompositions. Computer Networks 93, Part 3 (2015), 492 – 505. https://doi.org/10.1016/j.comnet.2015.09.035 Cloud Networking and Communications II.
  • Seneviratne et al. (2017) S. Seneviratne, Y. Hu, T. Nguyen, G. Lan, S. Khalifa, K. Thilakarathna, M. Hassan, and A. Seneviratne. 2017. A Survey of Wearable Devices and Challenges. IEEE Communications Surveys Tutorials PP, 99 (2017), 1–1. https://doi.org/10.1109/COMST.2017.2731979
  • Sun et al. (2012) L. Sun, H. Dong, and J. Ashraf. 2012. Survey of Service Description Languages and Their Issues in Cloud Computing. In 2012 Eighth International Conference on Semantics, Knowledge and Grids. 128–135. https://doi.org/10.1109/SKG.2012.49
  • Vallina-Rodriguez and Crowcroft (2011) N. Vallina-Rodriguez and J. Crowcroft. 2011. ErdOS: Achieving Energy Savings in Mobile OS. In Proceedings of the 6th International Workshop on MobiArch. New York, NY, 37–42.
  • Williamson et al. (2015) J. Williamson, Qi Liu, Fenglong Lu, W. Mohrman, Kun Li, R. Dick, and Li Shang. 2015. Data sensing and analysis: Challenges for wearables. In The 20th Asia and South Pacific Design Automation Conference. 136–141. https://doi.org/10.1109/ASPDAC.2015.7058994

Appendix A Brute Force Search

Example : Let’s consider an example use case where there are two devices (i.e., Smartphone-P and Smartwatch-W), and there are two functionality requests coming from each device for accelerometer data and gyroscope data. Applications installed in each device is requesting data in every 1 minute.

In this method, we consider all the possible assignments of the functionalities and find the maximum of the ON time of any of the devices in each assignment. Then we find the assignment that has the maximum from this maximum ON time. We calculate the computational complexity of brute force search.

  • Number of devices - 

  • Number of function types - 

  • Number of requests for each function type - 

  • Number of devices that has the function type

  • Number of requests from the function type

  • Number of Combinations () =

  • Worst case 1cm
    1cm

    1cm

  • Calculating each entry in the table and check whether the entities satisfies the each device’s requirement = =

  • Finding the minimum in one combination =

  • Finding the minimum in each combination = =

  • Finding the minimum among all the minimum values = =

  • Total Complexity 1cm=

As expected, the calculated complexity of the brute force method is in exponential time.

Appendix B Branch and Bound Method

These algorithms are nonheuristic, in the sense that the sub optimal solutions are eliminated only after making sure that they do not lead to the optimal solution. Let’s consider an example with real cost values. Table 4 shows the real energy values per minute. We consider remaining battery is 20% in the smartphone (which has for the 100% battery capacity) and 70% in the smartwatch (which has for the 100% battery capacity). Moreover, we consider smartphone and smartwatch are consuming and per minute respectively. In this example scenario, we neglected the idle energy for the communication which are in smartphone and in smartwatch.

There are different functionality requests coming from the devices. These different types of requests can not be mapped to the other types of functions. As an example, accelerometer functionality request can not be fulfilled by running the gyroscope.

As a solution, we can try and consider individual optimization problems for different functionalities and then combine the results to get the final results. However, this particular optimization objective does not allow to go for that type of solutions as the selections of one type of functionality directly influences the solutions of other types of functionalities.

Therefore, in order to avoid these types of difficulties, we alter the consideration of the first selection of the functionalities. Basically, we group the functionalities just for the first selection in a way that one group contains all the requested functionality types. We consider every possibility of combinations. Once we select the best combination of functions as per the objective, we check with the additions and removal of each and every other functionality from the next step.

  • Cost Value : Here we consider the inverse of the maximum of the ON time of any of the devices. At each step we consider the maximum ON time of any of the devices. This cost value has two bounds which are the Upper Bound and Lower Bound.

  • Upper Bound : The local minimum of the cost value. This value is calculated by connecting request only to the opened functions.

  • Lower Bound : The local optimum solution that would lead from the particular solution is always higher than the lower bound. This value is obtained by connecting requests to the opened and unknown functions, but not to the closed functions.

  • Pruning Rules : If the Upper Bound is larger than the parent node, the branch is pruned.

    (300,0) (0,0) (,) (142,36) (,)
    (660,0) (,) (0,0) (,) (142,36)
    (0,600) (142,36) (,) (0,0) (,)
    (0,960) (,) (142,36) (,) (0,0)
Table 4. Energy costs per minute. (Phone’s energy usage, Watch’s energy usage)
Figure 5. An example for Branch and Bound method

In contrast to brute force search, in this method, we do not consider every possible combination of the functions allocation in this method as we prune some branches once we confirm that they do not lead to the optimum solution.

Next we calculate the computational complexity of this method for this particular case. Let’s assume the , and has the same meanings as in the previous sub section.

First, we consider the computational complexity at the first branching.

  • Taking the possible combinations for the first branching.
    1cm=

  • Calculating UB for each combination.

    • As all the requests for are assigned to the function , there are no selected assignments. Calculate for all the devices, check whether the , and select the minimum.
      1cm=

  • Calculating the LB for each combination.

    • Consider each device separately, and for each request try to get the assignment that requires least energy from the considered device.
      1cm=
      1cm=

    • Select the min of
      1cm=

  • Total complexity of first branching
    1cm=
    1cm=

Next, we calculate the computational complexity during rest of the branching. The selection of the next function to be opened is decided by the fact that the most popular function during the lower bound calculation and that is not opened yet.

  • Calculating each value of the next branches from the initial selection
    1cm=
    1cm=

  • Calculating UB for each combination

    • Consider each device separately, and for each request try to get the assignment that requires least energy from the particular device
      1cm=
      1cm=

    • Check whether the
      1cm=

    • Select the min of
      1cm=

  • Calculating the LB for each combination

    • Consider each device separately, and for each request try to get the assignment that requires least energy from the particular device
      1cm=
      1cm=

    • Select the min of
      1cm=

  • Total complexity of next branching
    1cm= 1cm= 1cm=

The overall complexity is the aggregation of the two steps. However, as expected, this method also provides the exponential complexity.

  • Total Complexity 1cm=