Quality-of-Experience-Aware Incentive Mechanism for Workers in Mobile Device Cloud

Mobile device cloud (MDC) is a collaborative cloud computing platform over which neighboring smart devices form an alliance of shared resources to mitigate resource-scarcity of an individual user device for running compute-intensive applications. A major challenge of such a platform is maximizing user quality-of-experience (QoE) at minimum cost while providing attractive incentives to workers’ mobile devices. In state-of-the-art works, either a voluntary task execution or merely resource-cost driven mechanism has been applied to minimize the task execution time while overlooking payment of any additional incentive to the worker devices for their quality services. In this paper, we develop a computational framework for MDC where the afore-mentioned challenging problem is formulated as a multi-objective linear programming (MOLP) optimization function that exploits reverse-auction bidding policy. Due to the NP-hardness of MOLP, we offer two greedy worker selection algorithms for maximizing user QoE or minimizing execution cost. In both algorithms, the amount of incentive awarded to a worker is determined following the QoE offered to a user. Theoretical proofs of desirable properties of the proposed incentive mechanisms are presented. Simulation results illustrate the effectiveness of our incentive algorithms compared to the state-of-the-art approaches.


I. INTRODUCTION
With huge advances in recent years, mobile devices (e.g., smartphones, smartwatches, and tablets) have become ubiquitous and are rapidly growing as a dominant computing platform for users. These devices, which are equipped with a plethora of embedded sensors (e.g., GPS, camera, audio, proximity, and temperature), facilitate the running of many compute-intensive mobile applications such as intelligent The associate editor coordinating the review of this manuscript and approving it for publication was Xujie Li . transportation, natural language translation, augmented reality, and real-time health monitoring [1], [2]. Although the divergence of mobile applications is increasing every day, the execution performance is not yet sufficient due to resource constraints, mainly in terms of limited CPU, memory and battery capacity [3], [4]. To enhance the computation performance of mobile applications, some researchers have introduced mobile device cloud (MDC) [5]- [8] which is an opportunistic computation offloading technology that exploits idle resources of stationary mobile devices; it is also sometimes referred to as Mobile Ad-hoc Cloud [9], [10]. Mobile devices in a large scale stationary location (e.g., theater, shopping mall, stadium, or restaurant) or onboard a vehicle (e.g., bus, train, airplane) may collaboratively form a cloud service infrastructure to perform text translation, healthcare data processing, reality augmentation, etc. in real-time. A study shows that mobile devices are kept in idle state approximately 89 % of the time, and during this period they consume not more than 11 % of the available system resources [11]. The idle resources from such a plethora of mobile devices present untapped computing opportunities [12]. The MDC technology not only mitigates scarcity of computation resources in cloudlet-based offloading mechanisms [3], [13], [14] but also resolves communication latency of remote clouds [1], [15], [16].
Typically, an owner of an application (i.e., a buyer device) offloads an application code to the MDC manager, and then it is executed by different worker devices (i.e., sellers) having a sufficient amount of idle resources. It is important to ensure participation of nearby worker devices in such computation system so as to exploit unused resources efficiently. In stateof-the-art works, authors have focused on designing an MDC framework, where the worker devices participate voluntarily in the task execution process [6], [7], [12]. However, these methods lack to attract a good number of reliable and resource-rich workers in the resource-trading mechanism. To overcome this problem, auction mechanisms have been introduced to select resource-rich workers that minimize user cost [17], [18] or maximize workers' profit [19]- [21]. However, these works suffer from providing quality execution through reliable workers. Moreover, it is still unexplored to investigate the impact of user Quality-of-Experience (QoE) for executing tasks in an MDC environment. The QoE metric quantifies improvement of execution time of an offloaded task observed by the user. Focusing only on minimizing execution cost leads selection of unreliable and/or poor workers, hampering the user QoE. On the other hand, a worker device expects payment in return of task execution that acts as a compensation for dynamic usage of resources (e.g., CPU, memory, and energy) and bandwidth charges. Furthermore, an application user (i.e., buyer) might be motivated to pay more only if s/he receives high quality execution supports from worker devices. Hence, it is a pre-eminent concern to design an incentive mechanism to enhance worker participation, while considering the resource capacity and reputation of worker devices to execute the tasks with the aim of increasing user quality-of-experience (QoE).
In this paper, we focus on the selection of reputed and resourceful worker devices to execute tasks of an application and incentivize them based on the quality of execution. We consider an MDC system consisting of a cloudlet acting as a cloud broker and a set of participating mobile devices (i.e., user and workers), as shown in Fig. 1. The user device has an application (with a set of individual tasks) that requires offloading to the cloudlet for execution. After getting an announcement from the cloudlet, a worker device expresses its willingness to execute a certain task/tasks. Following the reverse-auction bidding policy, the cloudlet then determines an optimal mapping of the tasks to be executed on the worker devices so as to maximize user QoE and minimize execution cost. After successful execution of the assigned tasks, claimed cost with additional incentives according to execution quality are paid to the worker devices. The key contributions of this work are summarized as follows: • We design a framework for a QoE-aware incentive mechanism to execute applications by workers in MDC.
To the best of our knowledge, this is the first work to improve the user-QoE through incentivizing worker devices in addition to their regular bid payment, according to task execution quality.
• We formulate a multi-objective linear programming (MOLP) function that determines the optimal provisioning of application tasks on high performing worker devices with the aim of increasing user QoE with reduced cost.
• Due to the NP-hardness of MOLP, we develop two greedy task-worker assignment algorithms and incentive mechanisms to facilitate resource sharing using reverse-auction theory.
• The novelty of this work lies in paying additional incentives to the workers following their offered qualities of user task execution.
• The reliability and trustworthiness of the workers and the correctness of the incentive mechanisms have been proved theoretically.
• The performances of the proposed incentive mechanisms were evaluated in MATLAB [22], and significant improvements in user QoE and cost reduction were demonstrated.
The remainder of this paper is organized as follows. Section II presents state-of-the-art works in MDC and incentive mechanisms. The computation framework is presented along with our assumptions in Section III. Section IV formulates the worker device selection and incentive disbursement methods and presents a theoretical analysis. Section V presents the simulation environment and experimental results VOLUME 9, 2021 of the proposed incentive mechanisms with comparative analysis. Finally, the paper is concluded in Section VI.

II. RELATED WORKS
The key idea of this work is to provide an incentive to MDC workers according to execution quality of the tasks rendered by them. However, state-of-the-art-works in the literature have only disjointly addressed these two issues, as described below.

A. TASK EXECUTION IN MDC
The increasing number of smartphones has brought an enormous opportunity for code offloading to nearby mobile devices. A significant number of recent works have demonstrated the benefits of exploiting idle resources of nearby mobile devices compared to executing applications on remote clouds. To minimize the task completion time Habak et al. proposed FemtoCloud [23], which is a dynamic and self-configuring cluster head-based MDC architecture coordinated by a cloudlet. The improvement was achieved by applying priority-based task assignment and an earliest deadline heuristic on task assignment and result collection, respectively. Mao et al. [24] formulated a Lyapunov optimization-based dynamic computation offloading algorithm exploiting the resources of nearby energy harvesting devices to minimize the task execution latency and task failure of offloaded application tasks. However, these works incurred a huge burden on the potential workers due to biased assignment of tasks.
To optimize the application's execution performance, Le et al. provided a collaborative infrastructure among nearby mobile devices by leveraging Wi-Fi Direct technology that not only minimizes energy consumption but also expands the hardware capability of mobile devices [8]. The simulation results also reveal that task execution with nearby mobile devices is more beneficial compared to remote cloud server-based execution due to higher communication latency of cellular networks.
Balasubramanian and Karmouch [9] exploited the resources of nearby mobile devices to provide Infrastructure as a Service in the Mobile Ad-hoc Cloud Computing environment. They also outlined necessary architecture and algorithms to create a pool of devices with dedicated resources and efficient utilization of those resources. Later the authors formulated a model to ensure the parallel execution of tasks with a minimum number of worker devices [10]. A composition score was calculated based on the shared resources of the device (CPU, Memory, and Storage) to guarantee the selection of the best available devices for task execution.
Lin et al. [25] proposed a code offloading framework named Circa that exhibits the feasibility of code offloading in the proximity of nearby mobile devices exploiting iBeacons, a wireless location-based transmitter system. The system used an efficient and fair task allocation algorithm to disseminate tasks of an application among reliable worker devices.
In [26], Guiguis et al. delineated transient clouds, a collaborative computing framework for the offloaded execution of tasks with the help of nearby mobile devices. The authors explored centralized and distributed approaches to allocate tasks among mobile devices according to their capabilities. A modified Hungarian algorithm had been introduced in the centralized approach to balance the workload and Distributed Hash Tables were used to minimize the communication cost in the distributed mechanism. To execute the application tasks of multiple users, Ning et al. [27] considered both cloud and edge devices to offload application tasks for minimizing execution delay of latency-sensitive applications and formulated a MILP problem considering the resource contention among the mobile users. In [28], Fernando et al. employed a preemptive work-stealing mechanism on a set of worker nodes to balance workload and minimize execution time. Considering user mobility, task properties, resources and energy constraints, Saleem et al. [29] proposed a D2D-enabled task assignment and power allocation mechanism to minimize the task execution latency in MEC. To tradeoff between energy consumption and service latency, Yadav et al. [30] proposed an energy-efficient computation offloading and resource allocation mechanism considering vehicular node mobility and end-to-end latency deadline in Vehicular Fog Computing. However, the models completely ignores the reliability of the edge worker devices.
All the above-mentioned works significantly minimized execution time by offloading tasks to nearby mobile devices. Although these works focused on minimizing execution cost based on worker' bids and user budget, their worker selection strategies completely ignored user QoE. Moreover, none of these considered any incentive for the worker devices for executing the tasks.

B. INCENTIVE MECHANISM IN MDC
The actual benefit of the emerging MDC technology can only be utilized through effective participation of mobile worker devices in the computation process. Introduction of a reward mechanism can incentivize the use of mobile device resources, increasing motivation for worker devices. In the literature, mobile cloud-based computing systems have exploited a reverse auction mechanism, where a buyer places a request for a service and many sellers bid the minimum value they must be paid for the service, and the bidder with the lowest offer wins the auction.
In [6], Miluzzo et al. provided an outline of an incentive mechanism for resourceful nearby mobile devices that run compute-intensive offloaded tasks of an application in an MDC system. Though the incentive mechanism considered execution cost parameters, such as waiting time and bandwidth usage, few other influential parameters, such as worker reputation, workload, and task interdependency, were not considered in system design. On the contrary, Noor et al. [17] proposed a task allocation strategy based on worker reputation to assign tasks to different worker devices. In [31], Yadav and Zhang proposed an adaptive energy-aware heuristic algorithm to detect overloaded hosts and a dynamic VM selection algorithm to minimize the energy consumption and to maximize the quality of service in a mobile cloud computing environment. However, they neither provided any incentive to reputed workers in the system, nor did they consider QoE.
To incentivize worker devices, Duan et al. proposed a homogeneous and a heterogeneous reward models for data acquisition and distributed computation applications, respectively [19]. Data acquisition applications exploited a Stackelberg game model and distributed computation applications applied a procurement auction mechanism to incentivize individual workers. In [18], Wang et al. considered a game theoretic approach to find an equilibrium point for user cost and worker profit for an optimal allocation of tasks in worker devices. Though the system gives benefits to both buyer and seller devices, it aims to minimize user cost in the context of remote cloud price, which is often not practical. Considering resource capacity and task heterogeneity, Wang et al. proposed two winning bid determination algorithms for heterogeneous and homogeneous task models, respectively to execute the offloaded tasks in an MDC environment [20]. However, the bid winning worker devices were paid with the immediate next bid of the corresponding task, leading to overpayment of the workers. Later, Tang et al. [21], proposed a broker-based double-sided bidding mechanism to provide incentives to worker devices. The authors presented two game theoretic algorithms to find an equilibrium point that maximized the benefits for both user and worker devices. However, none of the works appraised task dependency and reputation of worker devices to execute tasks.
To encourage the participation of cloud service operators and local edge servers for computational offloading in mobile edge computing Liu et al. formulated a Stackelberg game that maximizes the utilities of individual entities [32]. Wang et al. proposed an auction model to increase participation of mobile devices that trades resources between task owners and worker devices [33]. Resource allocation and price estimation were determined through a distributed algorithm, while a payment evaluation procedure detected dishonest sellers in the system. Because bids were submitted privately to the selected participants, the optimal result could not be guaranteed from the system.
To stimulate service provisioning by edge clouds, Wang et al. utilized market-based pricing model to design a multi-round auction mechanism for the resource trading between edge clouds and mobile devices that incentivizes edge clouds for the allocated resources [34]. In [35], Li and Cai considered the collaborative task offloading problem as a social welfare maximization problem and applied a prime-dual framework to develop an online incentive mechanism for the execution of offloaded tasks. Considering the dynamic participation nature of the users and worker mobile devices, He et al. proposed an auction-based incentive mechanism for the execution of offloaded tasks that tried to optimize the long-term system welfare without future information of tasks [36]. However, none of the systems take into account the reliability of the edge devices/clouds in the offloading decision process that made the system vulnerable to the successful execution of application tasks.
All the above works focused on a general objective to minimize execution time and cost of a user where the workers were compensated with the bid amount. There were no consideration of additional payment as incentive following quality execution of a task. Moreover, most of the works not only ignored the reliability of devices while selecting the workers but also neglected the inter-dependency among the tasks. The key philosophy of this work is to select a set of reliable worker devices to execute an application task considering its dependency with others so as to minimize the user execution cost and to maximize the quality of execution. This novel strategy of rewarding worker devices with an additional incentive for offering high quality execution would help our system to attract more workers to participate and makes such MDC system sustainable.

III. SYSTEM MODEL AND ASSUMPTIONS
This section introduces a novel computation framework for an MDC system, interactions among its functional modules and assumptions made for modeling the task execution. In the remainder of the paper, without loss of generality, the terms buyer and seller devices should be considered synonymous to the terms user and worker devices, respectively.

A. COMPUTATION FRAMEWORK
We consider an MDC system with three different entities: users (buyers), workers (sellers) and a cloudlet (broker), which are working in two tiers. Mobile devices that are running applications that require additional resources (CPU, memory, etc.) for code execution, act as buyers and devices providing the required computation resources act as sellers; both reside at tier one. Interested seller devices bid for different application tasks based on their shareable resources. As presented in Fig. 2, the allocation and distribution of these tasks and resources are done by a cloudlet, which acts as the central controller for task execution and resides in tier two. The cloudlet also acts as a broker to select the winners from a pool of candidate workers and their payment disbursement. Detailed descriptions of four functional modules of our proposed computation framework are appended below.

B. TASK PROFILER (TP)
The TP module receives an application with an allotted budget (P) and an execution deadline through the task receiver component. It then uses the workload analyzer component to split the application into a set of atomic tasks M, where each atomic task m ∈ M contains S m number of instructions for offloaded execution. The dependency estimation component is responsible for determining the interdependency among tasks [37] which is used to identify execution order, facilitating parallel execution. The TP then hands the tasks over to the task advertisement component for advertising the tasks to VOLUME 9, 2021 the worker devices. Each advertised task is a three-parameters tuple denoted by < m, S m , T m >, where, m ∈ M is the task ID, S m is its number of instructions and T m defines the task deadline. Based on the task size and historical transaction prices, it also calculates maximum and minimum payable amounts (B max m and B min m , respectively) for each task to guard against bids from felonious workers [38]. The TP shares the lists of advertised tasks information with the The TWA.

C. TASK-WORKER ALLOCATOR (TWA)
The TWA module is the core of the proposed system, and it controls and coordinates functionalities of other modules. It triggers the TP to collect user applications and submits advertisements after profiling the application tasks. It collects worker bids (B) through the bids coordinator component. The worker devices send their device-specific information, identified by the tuple new < k, B k , R k , η k , H k >, which contains device identifier (k), workload capacity (H k ), associativity time (η k ), and a set of bids (B k ). Parameter R k is used to determine the aggregated resources required to execute a single instruction, whereas the workload capacity H k indicates the maximum number of instructions that can be handled by the worker [20], [33]. The associativity time η k indicates the expected amount of time the worker device will stay in the vicinity. Associativity time of a worker device can be calculated based on its contextual information and current GPS location which has been exploited in [39]. A single worker k ∈ K is allowed to bid for multiple tasks m ∈ M, and each bid B k m ∈ B is represented by tuple < k, m, b k m , Q k m >, which contains execution cost (b k m ) and execution quality (Q k m ) promised by the worker k ∈ K. However, to win a bid a worker device must have to satisfy the reputation and computation resource constraint in addition to bid cost. Moreover, a worker device will be entitled to execute multiple tasks only if it has sufficient computational resources and the tasks are sequential in order of execution.
All the collected bids and device information are then transferred to the TWA module to determine the winners among the submitted bids. After collecting all the bids from different workers, the TWA matches the advertised list of tasks with the corresponding worker bids to ensure that no task remains unbidden. Notifications of winning bids (W ⊆ B) are also dispatched through the same interface to selected worker devices (V ⊆ K). The TWA module interacts with the worker manager component to determine the dependability of workers to execute tasks successfully and to estimate the required cost. The worker manager component evaluates submitted bids to determine the quality and reliability of worker device through historical traces containing execution history and reputation information [40], [41]. After accumulating all information, it runs a worker selection algorithm to determine the winners from the set of candidate worker devices, and then it forwards the task-worker mapping list to the execution coordinator (EC) to schedule the tasks in order.

D. EXECUTION COORDINATOR (EC)
On reception of the task-worker mapping list from the TWA, the EC calls the task dispatcher component to schedule the tasks in order. This is to be noted that due to different computation and communication resources, the worker devices exhibits heterogeneous execution and communication latencies. However, ordered scheduling of the tasks helps to diminish any synchronization latencies due to such issues. After successful execution, results are collected and transmitted back to the user device with a payment (P ≤ P) disbursement request. Failed executions are reallocated by the TWA to the next available bidder. After the execution of all the submitted tasks, reputation of the allocated worker devices are updated according to their execution results and sent to the TWA module to store in the worker manager database.

E. PAYMENT MANAGER (PM)
The PM receives the agreed amount of payment from the user device through the payment receiver component. Upon getting the successful execution notification from the EC, the PM disburses the individual amount of payment (P v ) to the corresponding winning worker devices v ∈ V according to their bids along with incentives, if any, with the help of the payment provider component. It also collects a certain percentage of the worker bid cost as the utility (U 0 ) of the cloudlet, which is acting as a broker, coordinating all these transactions and communication activities on behalf of the user and worker devices.
The proposed incentive mechanisms trade among the seller devices to execute application tasks of a buyer with minimum cost and maximum quality. The incentive mechanisms should satisfy the following desirable properties: • Computational efficiency: An incentive mechanism is said to be computationally efficient if it can produce an auction decision in polynomial time.
• Individual rationality: The incentive mechanism must ensure a positive utility to bid-winning worker devices and the cloudlet to facilitate execution of application tasks, i.e., U k m > 0, ∀k ∈ K, ∀m ∈ M; U 0 m > 0, ∀m ∈ M, where U k m denotes the utility of worker k ∈ K for task m ∈ M. This basic requirement is mandatory to encourage the participation of worker devices in the system.
• Truthfulness: An incentive mechanism is truthful if it can guarantee that only the bidders declaring true costs are eligible to win the auction. No bidder can increase its utility by submitting a bid other than its actual cost.
• Budget balance: The incentive mechanism must guarantee that the total amount of payment P charged by different worker devices is within the budget allocation P of a user for a certain application, i.e., P ≤ P.

F. ASSUMPTIONS
Based on the state-of-the-art works, we have made the following assumptions in this work. We assume a rooted tree of application tasks as the vertices, and the linkages correspond to dependencies among the tasks. Execution of the tasks begins from the root, where parallel tasks start their execution simultaneously and dependent tasks start execution after completion of the parent task [4], [37], [42]. Hence, the execution performance of an application mostly relies on the number of dependent and parallel tasks. The overall execution delay is calculated considering both execution times and communication latencies involved.
We assume there will be a sufficient number of worker devices in the system to allocate all the application tasks, and each task will be bid on by at least one worker. The worker devices agree to execute tasks assigned to them, and each device will execute one task at a time [18], [20]. However, it may execute multiple tasks of one application. These worker devices are symmetric, independent, and risk neutral, having no security or privacy violations. A worker device may bid for multiple advertised tasks, where each bid has been generated randomly considering given task size and deadline. When a worker device submits quality information in a bid, it includes communication latency with actual execution time [43]. We assume the system will be running on a trusted platform where all executions will be in a secure environment and all the device-cloudlet interactions will be governed by proper authorization and authentication techniques [44]. We consider a quasi-static behavior for mobility of the user and worker devices to determine the associativity time (η), where the movement of the devices will remain relatively unchanged for a given period of time that is sufficient to execute the allocated task and return the result to the cloudlet [8], [26], [39]. In this work, current GPS location and contextual information have been used to determine the associativity time of a worker mobile device [39].
The major notations used in this paper are listed in Table 1.

IV. PROPOSED INCENTIVE MECHANISM
Successful execution of application tasks greatly depends on the selection of high performing and reputed worker devices. The execution time of an application task also significantly varies from one worker to another due to their resource heterogeneities, which offers varied QoE for users. This section first details the design of an optimal selection process of worker devices considering user QoE and task execution cost. Due to the NP-hardness of the optimal solution, we then develop greedy algorithms for task assignments on suitable workers so as either to maximize QoE or minimize execution cost. Finally, this section ends by presenting a QoE-aware incentive payment mechanism and theoretical proofs of its properties.

A. OPTIMAL SELECTION OF WORKER DEVICES
The competency of our proposed QoE-aware incentive mechanism mostly relies on efficient selection of worker devices so that the overall execution quality is increased and cost is decreased. The efficiency of application task allocations by the TWA module on different worker devices also depends on their reputations and resource availabilities. In addition to that, interdependency among the tasks and costs demanded by the worker devices for task execution are also important. Thus, provisioning of application tasks on worker devices is a multi-objective, multi-constrained problem. The next subsections describe methods for measuring user QoE and execution cost metrics, followed by formulation of an optimization framework for the problem.

1) USER QUALITY-OF-EXPERIENCE (QoE)
As discussed earlier, each task has an associated deadline T m determined by the cloudlet [45], within which the output of VOLUME 9, 2021 a task must be available to the cloudlet. Execution quality of an application, as termed as service level agreement (SLA) quality, is defined as the ratio of task execution time on the worker device to that on user device. Therefore, quality for a single task m ∈ M being offloaded to device k ∈ K can be calculated as where T k m denotes task execution time, and L k m indicates communication latency between worker device k ∈ K and the cloudlet during input and output transmission for task m ∈ M. The task execution time T k m is calculated by S m µ k , where µ k represents the CPU speed of a worker device k ∈ K. The ratio T k m +L k m T m < 1 because execution delay cannot exceed the deadline for any task. Now, combining the quality of all tasks, the QoE observed by the user for an application can be expressed as The target of our QoE-aware incentive mechanism is to increase the value of Q for a user application.

2) COST OF EXECUTION
A worker device participating in task execution incurs a cost due to usage of a certain amount of resources (CPU, memory, bandwidth, etc.). Therefore, a payment for the used resources is necessary to incentivize the worker device, promoting this service model [20]. The cost to execute each task m ∈ M is determined by the amount of resources utilized by the task during task execution time. The amount of computation resources (CPU clock speed) required to execute task m ∈ M with task size S m can be given as where R k is the resources required by candidate device k ∈ K to execute a single instruction. Then, the total cost is calculated by considering cloudlet utility along with execution cost. Now, considering C k to be the cost of utilizing a unit resource in device k ∈ K, the cost of executing task m ∈ M can be determined by After successful completion of a task, the corresponding worker devices earn payments with incentives in line with their execution qualities. From application task profiling and worker selection to task dissemination, the cloudlet controls and coordinates the whole process of execution in the MDC system. Thus, our worker devices pay a certain proportion of their bid amounts to the cloudlet as a coordinating utility. The utility of the cloudlet for executing task m ∈ M by candidate device k ∈ K is where b k m is the price of bidding by worker device k ∈ K to execute task m ∈ M that contains a marginal profit with accumulated costs for used resources and cloudlet payment, and λ is the utility percentage that will be given to the cloudlet for coordinating this task assignment and execution. The value of this utility percentage is a system design parameter, and it may vary from one cloudlet to another over a given period. The total utility of the cloudlet U 0 for providing necessary support to execute all tasks of an application is scaled by Therefore, the utility of candidate k ∈ K for executing a single task m ∈ M is where C k m is the actual cost of executing task m ∈ M on device k ∈ K. Accumulating the cost of each task m ∈ M in the application, we can get total bidding cost of application execution on the candidate devices, quantified as where binary variable y k m ∈ {0, 1} takes value 1 if task m ∈ M is executed on worker device k ∈ K and 0 otherwise. Hence, the normalized bidding cost C of the user is gained by where P is user-sanctioned budget for execution of the complete application and is the summation of the maximum allowable bid costs for each task m ∈ M, i.e., P = |M| m=1 B max m . While selecting worker devices, the proposed incentive mechanism aims to minimize this normalized execution cost for an application.

3) OPTIMAL OBJECTIVE FUNCTION
The selection of an optimal set of candidate devices for offloading tasks of an application can now be formulated as subject to: U k m > 0, ∀k ∈ K, ∀m ∈ M; U 0 > 0, ∀m ∈ M (15) k∈K y k m = 1, ∀m ∈ M.
In the above formulation, the aim of the objective function (10) 1 is to excel in task QoE while reducing execution cost. It chooses a bid set W from the power set of bids P(B), which optimizes the said parameters. Here, β is the relative weight parameter, which works as a control knob. Its value can be tuned to obtain different tradeoff levels between application QoE and execution cost required by various types of applications. Setting β = 1 translates it into a quality maximization problem, and β = 0 makes it a cost minimization problem, while other values correspond to various quantified levels of tradeoff between the two. The cloudlet determines an appropriate value of β following user demands.
The budget constraint defined in (11) means that the total payment of workers must not exceed the user-sanctioned payment. The availability constraint (12) specifies the minimum amount of time a selected candidate device must stay in the system. Here, m is the set of parents of a task m ∈ M and n,m is the percentage of dependency of a child task m ∈ M on its parent n ∈ m [37]. The reputation constraint (13) ensures that to win an auction for any task m ∈ M, the reputations of each selected candidate must be greater than a certain minimum threshold. The taskload constraint (14) refers to the fact that a candidate device's total assigned taskload must be less than or equal to its specified maximum capacity H k . The utility constraint (15) ensures that each device executing a task of an application will earn positive revenue. The cloudlet will also earn positive utility for supporting the execution service for each individual task. Similarly, the atomicity constraint (16) confirms that a single task will not be assigned to multiple candidate devices, and each task should be executed only once.
Theorem 1: The proposed worker device selection problem in (10) is NP-hard.
Proof: The optimization framework in (10) is a MOLP because since it contains two conflicting objectives (i.e., maximizing quality and minimizing cost) with combinatorial and continuous constraints. The worker selection problem can be reduced to a multiprocessor scheduling problem (an NP-complete scheduling problem) [46] by leveraging the constraints and considering that all workers offer equal quality. Hence, the proposed MOLP problem is NP-hard and cannot provide a polynomial time solution.
In a practical MDC platform, a typical application containing approximately 10 − 15 individual tasks may generate thousands of bids. To find boundary values of worker and tasks in a typical MDC environment, we simulate the objective function in NEOS optimization server (2× Intel Xeon e5-2698 @ 2.3GHZ CPU and 92GB RAM) with β = 0.5. The graphs in Fig. 3 show that the computation time for a higher number of tasks and workers exponentially increases due to exploring an enormous number of task-worker assignments. For 20 tasks and 30 workers, 1 Please note that (10) is not a typical multi-objective optimization problem; rather, it brings a tradeoff between the two conflicting objective parameters -quality and cost.  the run time exceeds 100 seconds, which might not be tolerable for a decision-making algorithm. In a separate experiment, the impact of weight parameter (β) was studied for 12 tasks and 20 worker devices as shown in Fig. 4. The graphs show that with the increasing β value, the user QoE increases and the user payment saving amount decreases. Our further studies on QoE and payment savings have been discussed in Section V.
Since, the above formulation turns to be an NP-hard problem, we develop two greedy solutions for assigning tasks to workers to overcome the problem.

B. GREEDY SELECTION OF WORKER DEVICES
To support real-time processing of user applications, this section introduces light-weight greedy worker selection algorithms focusing on either maximizing execution quality or minimizing execution cost. Algorithm 1 selects workers that maximize task execution quality while maintaining total cost within the allocated budget. On the other hand, Algorithm 2 selects workers that demand minimum cost while maintaining the required quality of execution. Detailed descriptions of the algorithms are given in the following subsections.
their execution qualities (line 3). First, the algorithm prepares a candidate bid set after pruning the bids that cannot meet the minimum reputation and fall outside of the bid boundary. These bids are sorted with higher quality values and stored in the priority queue (lines 4 − 8). Then, the task of the topmost bid is assigned to the corresponding worker device that fulfills the required resource requirements (lines 10 − 11). After successful task assignment, the corresponding task and the bid is removed from the queue and the procedure is repeated until all the tasks assignment are completed (lines 9 − 17).

2) MINIMIZING TASK EXECUTION COST
The algorithm selects worker devices that can satisfy execution constraints, ascertain minimum execution quality, and reduce overall execution costs. Delay tolerant applications, such as text translation, audio video transmission, online forum, and blogging can compromise in terms of execution quality, providing us the opportunity to minimize execution cost.
Algorithm 2 follows similar steps of Algorithm 1, except the priority queue B is based on minimum execution cost (line 6). The algorithm selects all bids that provide minimum task execution cost and ensures at least the minimum quality (lines 4 − 17).
What we unfold next is the process of providing additional incentives to the high performing workers following their offered qualities of task executions. Note here that the incentive mechanisms are applicable for workers assigned tasks either by MOLP system or greedy algorithms.

QUALITY-OF-EXPERIENCE-AWARE INCENTIVE MECHANISM
Upon successful execution of all tasks of an application, payment is calculated for disbursement to the corresponding bid winners v ∈ V. A worker device is paid the bid amount (b v m ) and an additional incentive based on the executed task quality (Q v m ), which is measured after task execution. This incentive might play a vital role in motivating worker devices to submit rational bids and increasing participation of valued workers in the bidding process.
The entitlement of an incentive depends on two parameters. Firstly, the bid cost must be less than the maximum budget for the task (i.e., b v m < B max m ). Secondly, the provided execution quality of a task must be higher than the committed quality (i.e., Q v m > Q v m ). If these two criteria are fulfilled then we calculate the amount of bonus quality provided by the worker device, i.e., ( . A worker device is given a portion of the unused budget (B max m − b v m ) as an incentive for the provided bonus quality. Otherwise, the worker will not be entitled to any incentive amount. Thus, we calculate the incentive amount σ v m as Now, the cloudlet is responsible for computing the required payment to the worker devices. A detailed description of the Algorithm 3 Incentive Payment for Winner Devices INPUT: Set of winning bids, W, from Algo 1 or Algo 2. OUTPUT: Payment P v for winner device, v ∈ V, Total amount of payment, P for the user application.
Calculate incentive amount, σ v m using Eqn. (17) 6. P . end for 10. end for 11. return P v , P payment strategy for bid-winning worker devices is presented in Algorithm 3.
After completion of all tasks, the cloudlet picks a worker device and calculates incentives of each task executed by it using (eq. 17), total payment for the task (P v m ), and payment for all the executed tasks (P v ). These steps are repeated for all the worker devices (lines 3 − 7). Finally, the cloudlet calculates the total actual payment (P ) of the user and disburses payments to individual workers upon reception of actual payment from the user (line 8). We call the incentive payment mechanism IMaxQ when the workers are selected to maximize task execution quality (in Algorithm 1) and IMinC when the workers are selected to minimize task execution cost (in Algorithm 2).

D. UPDATING REPUTATIONS OF WORKER DEVICES
Reputations of worker devices are updated by the TWA module based on the execution results of the tasks; this is important for selecting winning devices in future task assignments. To encourage truthful bidding, successful execution with the offered quality provides a positive reputation, whereas failure in maintaining the offered quality or deadline results in a penalty to protect against dishonest activity of unqualified workers.
To calculate the reputation of a winning device v ∈ V, the cloudlet first calculates the quality enhancement indicator E v m of the executed task based on qualities Q v m and Q v m offered in SLA and provided by the worker, respectively.
The task quality enhancement indicator (E v m ) is used to calculate the reputation/penalty value gained for executing the current task m ∈ M as where α is a weight parameter used to put emphasis on the currently availed reputation/penalty. In this work, the value of α was set to 0.1, placing only a small significance on the reputation achieved for executing the current task. The binary variable x v m ∈ {1, 0} is used to represent service level agreement (SLA) retention status. x v m is set to 1 if worker device v ∈ V successfully executes task m ∈ M, maintaining Q v m ≥ Q v m ; otherwise, it is set to 0. Similarly, binary variable y v m ∈ {1, 0} takes value 1 if task m ∈ M successfully executed on the worker device v ∈ V and 0 otherwise. Finally, the reputation of a worker device is updated for future task assignments considering previous reputation as Equation (20) bounds the reputation for a worker device v ∈ V between 0 and 1. In this work, the initial reputation of a worker device was considered as 1.0 to encourage new workers to participate in the MDC system. Note that (19) and (20) jointly ensure that on-time successful execution increases the reputation of a worker and that delayed or failed execution causes a penalty for the device. In this way, the dynamic reputation update of a worker facilitates our proposed incentive mechanisms to select high performing workers for task execution, increasing user QoE as well as incentives for workers.

E. AN ILLUSTRATIVE EXAMPLE
This section presents an illustrative example on operation processes of the proposed IMaxQ, IMinC and Optimal solutions. Consider a scenario depicted in Fig. 5, where the cloudlet divides an application into three tasks: M 1 , M 2 , and M 3 with allowable maximum execution costs 3, 5, and 7 units, respectively. We also assumed that five worker devices K 1 −K 5 available in the system bid for the designated tasks shown by edges (in Fig. 5, labeled with bid cost and committed quality). The instruction sizes and deadlines of the tasks are labeled at the top and available resource capacities and reputations of the worker devices are labeled at the bottom.
The task assignment to different workers, their incentives, and user cost savings have been shown in following Table 2. It is to be noted here that the worker K 2 could not win any bid due to its poor reputation. Furthermore, as expected theoretically, the proposed IMinC has brought out the maximum cost savings for the user and IMaxQ has offered the lowest while the Optimal solution (with β = 0.5) has worked out with competitive savings. We also notice that, in all algorithms, tasks were executed satisfying the expected QoE within the allocated budget. Finally, the amount of incentive (σ v m ) awarded to a worker is directly proportional to the quality (Q v m ) it offers in executing a user task.

F. THEORETICAL PROOF OF DESIRABLE PROPERTIES
In this section, we provide theoretical proofs of the desirable properties of the proposed incentive mechanisms, including VOLUME 9, 2021 FIGURE 5. An example scenario for task assignment. computational efficiency, individual rationality, truthfulness, and budget balance. Proof: Consider the two following scenarios: 1) If a worker device k ∈ K wins no bid, it will have no resulting cost, C k = 0, payment P k = 0, and U k = 0. In this case, the utility of the cloudlet U 0 = 0. 2) If a worker device k ∈ K wins a bid, its utility is calculated as U k m = P k m − C k m − U 0 m , where payment is determined as P k m = b k m + σ . According to (5), cloudlet utility (U 0 m ) will be nonzero for a successful task execution by a worker device. Moreover, for a successful execution by a worker device, payment will be at least equal to the bid price. As worker devices bid for a task m ∈ M including cloudlet payment (U 0 m ) and its resource cost C k m , bid price must be higher than U 0 m + C k m , which has been ensured through constraint (15). Therefore, in conclusion, it can be clearly seen that the utility of a worker device and cloudlet will be nonzero.

Lemma 3:
The proposed incentive mechanisms are truthful.
Proof: Let U k m and b k m denote the utility and bid price, respectively, of a worker device k ∈ K if it bids with actual cost C k m , and letŪ k m andb k m denote the illegitimate utility and bid price, respectively, caused by bad intension of a worker, where b k m =b k m . To prove this lemma, we must show that only a truthful bid price can provide the maximum utility of a worker device, i.e., U k m ≥Ū k m , ∀b k m =b k m . In this case, we first consider Algorithm 2 (IMinC).
Assume thatb k m > b k m , a win ofb k m means that the worker wins when it bidsb k m , and a loss ofb k m means that the worker loses when it bidsb k m . Algorithm 2 confirms that a worker with minimum bid cost wins the bid. Hence,b k m loses the bid in the presence of another bid that equals b k m , and thus the utilityŪ k m = 0 and U k m >Ū k m . Ifb k m = b k m , then a win ofb k m means that b k m also wins. In this case, U k m =Ū k m signifies that the actual bid is made by a legitimate worker.
Lastly, ifb k m < b k m , thenb k m wins the bid according to the worker selection criteria. However, in this case, the expected utility constraintŪ k m < U k m is preserved. Similarly, for Algorithm 1 (IMaxQ), workers offering higher quality may submit overpriced bids. In this case, maximum bid cost (B max m ) for a task m ∈ M is used to guard against such dishonest activity and reject such bids during the candidate worker set generation phase, which results in utility U k m = 0 for worker k ∈ K. Moreover, the incentive (σ ) for qualified execution induces extra profit to deserving workers. For this reason, workers are motivated in bidding with actual cost to increase the opportunities for a winning bid.
It is to be noted here that a worker might win a task by misreporting both the quality and bid but it would be penalized with a negative reputation due to failure in achieving the committed quality.
Lemma 4: The proposed incentive mechanisms are budget balanced.
Proof: The total amount of payment for a user to execute all tasks is calculated as P = |M| m=1 P k m , including their incentive (lines 4−7 in Algorithm 3). If all payments of tasks are equal to their maximum allowable bid prices (including incentive σ , if any), then the total payment will be P = C M = P (according to (8)); otherwise, the payment will be C M ≤ P ≤ P. This means that the total cost of an application execution will always be less than or equal to the budget allocated by the user, i.e., P ≤ P. Hence, the proposed incentive mechanisms maintain the budget balance property.

V. PERFORMANCE EVALUATION
The performances of the proposed IMaxQ and IMinC algorithms were compared with two state-of-the-art works (Min-Cost [20] and First-Fit [47]) through numerical simulations in MATLAB [22]. The Min-Cost algorithm employed a least cost per unit resource mechanism to select the winning bids. The workers that offer a minimum bid are selected for the execution of tasks and the corresponding worker devices were paid with the immediate next bid amount of the task. On the other hand, First-Fit is a baseline method extracted from [47] that greedily allocates tasks on worker devices with sufficient resources without considering execution quality, cost, or device reputation.

A. SIMULATION SETUP
We assumed that a number of user devices (buyers) issue application code execution requests to a nearby cloudlet on which there are 10 − 100 connected worker devices (seller), randomly distributed in a 50 × 50 m 2 area. A user application ranging the size from 100K − 500K instructions is supposed to execute in an MDC environment. Since the application will be distributed to a number of worker devices, it is split into a random size of smaller tasks containing instructions from 5000 − 125000. Now, to execute these instructions, worker devices are elected by the greedy algorithms in the system. We consider the capacity of a worker is randomly chosen from the range of 10, 000 − 1, 000, 000 units. For simplicity, we assumed 1 unit of resources is required to execute each instruction, where 1 unit of cost was estimated for every 10,000 units of resources. The maximum amount of bid (B max m ) for a task has been calculated based on the task size and the cost per unit of resources which has been varied according to the task size. The value of (B min m ) has been set to 0 in all experiments. To generate the simulation data, we have implemented an experimental testbed based on our preliminary works [12], [37]. In the experiments, the reputation threshold of a candidate worker was set to 0.6. The percentage of cloudlet utility λ, has been set to 20 %. All simulation experiments were conducted on a PC with an Intel Core i5 2.2 GHz processor and 8 GB memory running Windows 8.1. This is to note here that both the greedy algorithms run in polynomial time and the runtime of both algorithms is few milliseconds which has been ignored in the calculation of task execution quality in the simulation results.
To compare with the state-of-the-art works, at first, we estimate the execution time for the whole application in the user device. Then we compute improvement of QoE, payment savings, and user satisfaction based on execution time, bid amount and number of successful execution (without resubmission), respectively. Details of measuring each performance metric are explained in section V-B. This is to note that each simulation experiment was run for 500s, and the results collected from 50 runs with different random seed values were averaged to plot each data point with corresponding confidence interval in the graphs. A summary of the values and ranges of different simulation parameters is given in Table 3.

B. PERFORMANCE METRICS
We focused on the following performance metrics to evaluate the proposed methods and to compare them with other stateof-the-art methods.
• Improvement of user QoE: The user Qualityof-Experience (QoE) metric measures the task quality improvement of an offloaded task observed by the user. This gives the average percentage improvement of execution time in MDC compared to that of the user device. To compute it, at first, we estimate the execution time of the whole application in the user device. Then, we distribute the application among the selected worker devices based on the proposed greedy allocation algorithms. After getting the execution results, we compute execution time (including communication latency) for corresponding worker devices and the improvement of user QoE using Eq. 2.
• User payment savings: The user payment savings parameter reflects the surplus amount of the budget after the completion of payment and incentive of the worker devices. This is defined as the proportion of unused payment compared to the sanctioned budget of a user for a certain application execution; it is expressed as a percentage, i.e., (1 − P P ) × 100 %. To compute it, at first, we estimate the maximum budget (including cloudlet cost, bandwidth cost, resource compensation, etc.) for the whole user application to be executed in the MDC environment. Based on the bid amount in auction and execution time, the cloudlet disburses payments to the winner worker devices including incentives. It is to note that the eligibility of incentives is determined by Eq. 17. Finally, we compute the payment savings with respect to estimated budget and total expenditure including incentives and bid cost.
• User satisfaction: This is the percentage of successfully executed tasks (without resubmission) out of all offloaded tasks. VOLUME 9, 2021 FIGURE 6. Impact of varying number of tasks.

C. RESULTS
This subsection provides the experimental results and discussion on the comparative performances of the studied systems.

1) IMPACT OF VARYING NUMBER OF TASKS
In this experiment, we fix the number of worker devices to |K| = 50 and application size to 200K, and we vary the number of tasks from 4 − 24. The number of instructions in each task may vary from other tasks and due to fixed size application, the number of instructions of an individual task is reduced with increasing number of tasks. Fig. 6(a) shows the improvement of user QoE achieved by the proposed incentive algorithms compared to existing approaches. We observe that the user QoE increases with the number of tasks, and it reaches its peak point when the task population is close to 12. This trend is reasonable since a few capable workers are able to bid and win the tasks at the beginning due to relatively large instruction size of the tasks. When size of an individual task is decreased, the number of capable worker devices for executing the task is increased that facilitated more parallel execution and enabled their executions on highly qualified workers till the saturation point. After that, admission of an additional number of tasks in the system forces it to allocate mid-level or even poor capacity and/or low-quality workers to allocate for the execution of tasks, causing degradation of user-QoE. The graphs also depict that the proposed IMaxQ offers the highest quality (35 %) as it is expected theoretically. Since IMinC and Min-Cost prefer workers with low cost rather than high quality and thus their performances are significantly less compared to IMaxQ. Similarly, due to the random selection of workers, First-Fit provides the worst user QoE among all.
On the other hand, in Figure 6(b), IMinC offers the highest user payment savings with an increasing number of tasks compared to all other incentive algorithms. In the beginning, a few tasks containing higher instruction sizes were bid by a limited number of capable workers at a high cost. Due to this monopolistic competition, such execution leads to small savings for the user. As the number of tasks increases, the amounts of savings also rises in all algorithms. This is due to the fact that more low-cost offering workers were able to compete that assisted better worker selection and execution quality with relatively lower bid cost, resulting higher cost savings for the user. Nevertheless, further increase of tasks (|M | >= 16) causes a sharp fall in savings since the system is bound to select workers with high bid costs to accommodate the increasing number of tasks. By comparison, IMinC provides the highest payment savings (31 %) and Min-Cost's user payment savings percentage is somewhat lower than that of IMinC because it pays worker devices with the immediate next bid winner's cost. IMaxQ cannot provide low cost execution due to the selection of higher quality workers. Due to the random selection of workers by First-Fit, it provides the least payment savings. We also measured the satisfaction level of application users offered by the studied systems through on-time execution of tasks, as shown in Fig. 6(c). We observed that the user satisfaction rates for all studied algorithms increased with the number of tasks until peaking at approximately |M | = 12, and then they started to decrease slowly. Initially, the size of each task was relatively bigger due to a small number of tasks in an application. As a result, a few number of resource-rich workers were able to win the bid and provide successful execution. Dividing the application into more number of tasks instigated more quality workers with a better reputation get a chance to win bids, resulting in higher successful execution. Further increasing the number of tasks implies that each task contains a fewer number of instructions, demanding allocation to more workers of the system. This consequence diminishes user satisfaction due to allocations of tasks to relatively poor workers. Hence, user satisfaction is increased slightly at the beginning and is reduced gradually after reaching a pick point. In comparison, IMaxQ and IMinC provide better user satisfaction than Min-Cost and First-Fit, and IMaxQ provides the best. This is due to the consideration of worker reputation, which allocates a task to reliable devices in addition to available computation resources. Moreover, lack of consideration of task dependency incurs unnecessary waiting time for a task (dependent on a different one for data input) and hampers user satisfaction in Min-Cost and First-Fit.

2) IMPACT OF VARYING NUMBER OF WORKER DEVICES
Availability of worker devices creates an opportunity to select more appropriate resources for executing a task, resulting in better system performance. To investigate the impact of worker devices, we fix the number of tasks to |M| = 20 and application size to 200K and vary the number of worker devices from 20 − 100. Figure 7(a) shows that increasing the number of worker devices drives the average user QoE to rise sharply, and then it slows until it reaches saturation. This is due to the fact that with a fixed set of tasks (|M| = 20), increasing worker devices create an opportunity to allocate resources from more qualified workers, resulting in better user QoE. However, increasing worker devices cannot remarkably improve the user QoE when the system contains many qualified workers (|K| > 60) above the user demand. Our proposed IMaxQ and IMinC algorithms show better performances compared than the other. Task allocation to reputed workers with rich computing resources provides the finest result for IMaxQ, while IMinC sacrifices quality slightly to minimize execution cost.
A completely opposite phenomenon is illustrated in Figure 7(b), wherein the selection of worker devices with minimum bid cost provides superior performance for IMinC and Min-Cost compared to IMaxQ and First-Fit, while IMinC provides the maximum savings for a user. This figure also illustrates that user payment savings gradually increase due to the availability of a large number of worker devices offering relatively lower execution cost. However, availability of too many qualified workers (|K| > 60) cannot improve the user savings further as the system reaches saturation.
Similarly, increasing worker devices creates more opportunity to improve successful task execution rate, which facilitates higher user satisfaction, as shown in Figure 7(c). From this figure, it is also evident that our proposed IMaxQ and IMinC algorithms maintain significantly superior results than the other algorithms due to the consideration of task dependency, worker reputation, and available computing resources.

3) IMPACT OF VARYING TASK SIZE
In this experiment, we fixed the number of worker devices to |K| = 50 and the number of tasks to |M| = 20 and classified the application size into three categories: small (25K − 50K ), medium (100K − 200K ) and large (400K − 500K ) tasks.
As shown in Figure 8(a) and Figure 8(b), increasing the size of a task results in degradation of both user QoE and payment savings. This is due to the fact that increasing task size reduces the percentage of qualified worker devices to execute the task, resulting in relatively resource-poor workers being hired. For this reason, user QoE and user payment savings decrease with growing task size. However, due to the consideration of worker reputation, task dependency, and available computation resources, our proposed IMaxQ and IMinC algorithms still outperform the Min-Cost and First-Fit models, while IMaxQ has superior performance for user QoE and IMinC provides maximum cost savings. For the same reason, user satisfaction also decreases with growing application task size, as illustrated in Fig. 8(c). However, for allocation of tasks to reputed worker devices, our proposed IMaxQ and IMinC provide significantly better results compared to other algorithms.

4) INCENTIVES FOR WORKER DEVICES
In this experiment, we plotted the average amount of incentives received by different winning worker devices for executing a single application having 20 units of budget with fifty worker devices (|K| = 50). Figure 9(a) shows the impact of increasing the number of tasks on the distribution of amounts of the worker bids, incentives and savings. Initially, size of an individual task was relatively bigger. As a result, a few workers were able to win the bid with high bid cost, resulting small payment savings and incentives. Dividing the application into more number of small-sized tasks invited more quality workers with lower bid cost, resulting higher payment savings and incentives. However, further increasing number of tasks diminishes payment savings and incentives due to execution of tasks with relatively high bid cost workers. More specifically, in such situation, number of good quality workers is not enough to execute so many tasks. For the same reason, the graph follows similar trend for user payment savings. Comparatively, IMaxQ pays more incentive than IMinC as it prefers higher quality. Incentive performances for the Min-Cost and First-Fit algorithms are not presented here because these algorithms do not pay any additional incentives to workers above their bid amounts.
Similarly, increasing the number of worker devices causes more competition among the workers with fixed number of tasks (|M| = 20), resulting in higher user QoE with small bid cost, as illustrated in Figure 9(b). Therefore, the user gets the opportunity to pay a higher incentive for the worker resources. However, further increasing the number of workers (>70) resulted high quality execution from the worker devices though the incentive amount is decreased. At this point, due to high competition among the workers, the difference between the SLA quality and the provided quality of the workers becomes very little and hence the incentive amount is decreased even though the payment savings is increased. Though IMaxQ pays higher incentives than IMinC, the savings amount in Figure 9(b) is much higher compared to its counterpart shown in Figure 9(a). It is worth noting that although our proposed IMaxQ and IMinC algorithms provide incentives to workers, the savings are still higher than from other state-of-the-art-works due to the payment strategy. Our proposed resource allocation algorithms provide payment as the workers bid price, whereas other mechanisms use the next winner's bid cost to pay a worker, causing higher payment. However, our proposed allocation algorithms incentivize only the qualified workers, resulting in savings. Our in-depth look into the simulation trace files also reveals that, due to the payment of additional incentives, the participation of resourceful workers also increases gradually with the growing number of worker devices and execution of tasks with these worker devices upswing user-QoE. In summary, the amount of incentive received by a worker device is proportional to how much less time it takes for it to execute a task than the user deadline. Our in-depth analysis on results in the simulation trace file revealed that approximately 40 % of the workers are incentivized with an ample amount for offering excellent qualities of execution. Moreover, approximately 30 % of the workers are incentivized insignificantly due to bidding higher cost and offering just above SLA quality. The remaining workers are given negligible (or zero) incentives for just-in-time execution. Such a mechanism develops a win-win environment for users and workers, increasing the sustainability of the MDC system.

VI. CONCLUSION
In this work, we developed a QoE and Incentive-aware dynamic resource allocation framework for MDC, where mobile worker devices are incentivized in line with their execution qualities of user application tasks. Furthermore, consideration of resource capacity, reputation, and bid cost of worker devices helped our allocation algorithms to harvest maximum benefits (in terms of quality or cost) through efficient utilization and management of the idle resources. Incentivizing the worker devices proportional to offered task execution quality significantly increased the participation of the worker devices and improved the quality of experience of the users. The simulation results clearly indicated that the proposed system can maximize user QoE by as much as 35 % while minimizing cost by up to 30 %. The results also revealed that increasing the number of workers in the system can steadily improve user QoE, payment savings, and satisfaction, whereas larger task sizes can adversely affect MDC performance.
In this work, we have considered a fixed budget for the execution of an application that shrinks the worker selection due to budget constraints. In the future, given that the user budget for execution of application tasks is dynamically adjustable rather than being fixed, developing a resource allocation algorithm in an MDC environment that can further increase user QoE could be an interesting problem to solve. Moreover, other multi-objective evolutionary approaches can be considered to find an optimal solution with more number of instances to minimize the runtime complexity of the formulated MOLP objective function.  MOHAMMAD MEHEDI HASSAN (Senior Member, IEEE) received the Ph.D. degree in computer engineering from Kyung Hee University, South Korea, in February 2011. He is currently a Full Professor with the Department of Information Systems, College of Computer and Information Sciences (CCIS), King Saud University (KSU), Riyadh, Saudi Arabia. He has authored and coauthored around more than 180 publications, including refereed IEEE/ACM/Springer/Elsevier journals, conference papers, books, and book chapters. Recently, his four publications have been recognized as the ESI Highly Cited Papers. His research interests include cloud computing, edge computing, the Internet of Things, body sensor networks, big data, deep learning, mobile cloud, smart computing, wireless sensor networks, 5G networks, and social networks. He has served as the chair and a technical program committee member for international conferences. VOLUME 9, 2021