A Survey on Matching Theory for Distributed Computation Offloading in IoT-Fog-Cloud Systems: Perspectives and Open Issues

Fog computing has been widely integrated in the IoT-based systems, creating IoT-Fog- Cloud (IFC) systems to improve the system performances and satisfy the quality of services (QoS) and quality of experience (QoE) requirements for the end users (EUs). This improvement is enabled by computational offloading schemes, which perform the task computation nearby the task generation sources (i.e., IoT devices, EUs) on behalf of remote cloud servers. To realize the benefits of offloading techniques, however, there is a need to incorporate efficient resource allocation frameworks, which can deal effectively with intrinsic properties of computing environment in the IFC systems such as resource heterogeneity of computing devices, various requirements of computation tasks, high task request rates, and so on. While the centralize optimization and non-cooperative game theory based solutions are applicable in a certain number of application scenarios, they fail to be efficient in many of cases, where the global information and control might be unavailable or cost-intensive to achieve it in the large-scale systems. The need of distributed computational offloading algorithms with low computation complexity has motivated a surge of solutions using matching theory. In the present review, we first describe the fundamental concept of this emerging tool enabling the distributed implementation in the computing environment. Then the key solution concepts and algorithmic implementations proposed in the framework of literature are highlighted and discussed. Given the powerful tool of matching theory, its full capability is still unexplored and unexploited in the literature. We thereby discover and discuss existing challenges and corresponding solutions that the matching theory can be applied to resolve them. Furthermore, new problems and open issues for application scenarios of modern IFC systems are also investigated thoroughly.

quality of service (QoS) and quality of experience (QoE) requirements for some classes of IoT applications, especially latency-sensitive ones because of the long physical distance between the IoT devices and the remote cloud servers, scarce spectrum resources, and intermittent network connectivity.
This has led to the emergence of fog computing, which extends the cloud computing resources (i.e., computing, storage, and networking) closer to the data generation sources (i.e., IoT devices), thereby allowing for the prescribed QoS requirements of services and application to be met by enabling the fog computing devices (e.g., switches, gateways, and hubs) to process and offload most tasks on behalf of the cloud servers in a distributed manner [10], [11]. Recently, the advance of networking generation (i.e, 5G and beyond) leads to an increasing demand of ubiquitous computing and pervasive service accesses by a numerous number of Internet-connected mobile devices and end users (EUs). Motivated by the necessity of network architecture enhancement, a paradigm of fog radio access networks (F-RANs) has emerged as a promising evolution path for 5G network architecture [12], [13], which along with cloud radio access networks (C-RANs) [14] provide the pervasive computing services. In F-RANs, a fog computing layer is deployed at the edge of networks, allowing a part of the service and application requirements to be responded locally without the need of the centralized cloud computing. Therefore, by taking full advantage of distributed caching and centralized processing, F-RANs provide great flexibility to satisfy QoS requirements of various 5G-based services and applications. Besides providing the cloud like services to EUs, the fog computing potentially improves the performance of fog-based systems such as reduction of service delay [15], and energy saving [16] through efficient computational offloading algorithms [17]. Ultimately, IoT-Fog-Cloud (IFC) systems formed by the integration of IoT, fog, and cloud are able to provide uninterrupted services and applications with significant QoS improvement along the things-to-cloud continuum.
To further realize the above benefits of computing paradigms, the IFC systems require efficient resource allocation and management strategies to perform computational offloading operations [18]. However, there are many factors that challenge the design and development of effective offloading strategies. First, an IFC system consists of heterogeneous computing devices with different storage capacity, computation, and networking characteristics. Except the cloud servers, the IoT devices (e.g., smart phones, tablets) and fog nodes (FNs) (e.g., gateways, switches, and hubs) are resource constrained, thus limiting the capability of processing a large type of computation tasks. For example, some IoT and fog devices can support the process of only one data type such as image, text, video, or audio [19]. In addition, modern applications such as artificial intelligence and machine learning algorithms require to the computation of complex tasks, which typically include multiple types of input data [20]. Second, the diverse task requests also have a significant impact on offloading performance in the IFC systems. For example, some fog devices are unable to process the entire data of heavy tasks owing to a lack of storage and limitation of computational capability. Consequently, more tasks are likely to be queued in more powerful resource fogs causing the over-utilized workload at these nodes. Third, the request rate directly impacts on the queuing state of fogs. Therefore, without an efficient resource allocation policy, a high rate of task request may lead to a high workload imbalance among the fog devices, as the fog nodes with powerful computing resources may receive more task requests.
There are a large number of centralized optimization techniques and algorithms proposed in the literature to provide optimal solutions to the aforementioned resource allocation problems [21], [22]. For instance, offloading multiple tasks of fog nodes (FNs) to multiple neighbor FNs (i.e., helper nodes (HNs)) is modeled as a multi-task multi-helper (MTMH) problem, which aims to allocate the fog computing resources for processing tasks to minimize the average delay of task execution. The multi-objective optimization problem is also investigated to examine the trade-off of performance in terms of energy consumption, delay, and execution cost [23]. The optimization based solutions, however, require a centralized control to gather the global system information, thus incurring a significant overhead and computation complexity of algorithms. This complexity is further amplified by the rapidly increase of density and heterogeneity of IFC computing systems [24] because the centralized optimizations many not able to properly handle the challenges of dense and heterogeneous fog computing environment when dealing with combination integer programming problems [25].
The aforementioned limitations of optimization have lead to a second groups of solutions that apply the non-cooperative game theory to avoid the cost-intensive centralized resource management as well as substantially reduce the complexity of algorithms [26], [27]. Despite their potentials, such approaches pose several limitations. First, classical game theoretical algorithms such as best response require some information regarding actions of other players [28]. Correspondingly, many assumptions are introduced in the game theory-based algorithms to simplify the system models that, in some case, are impractical. Second, most game-theoretic solutions, for example, Nash equilibrium, investigate one-sided stability notions in which equilibrium deviations are evaluated unilaterally per player. In addition, in the IFC systems, the stability must be concerned by both sides of players, i.e., resource providers and resource requesters.
Ultimately, managing resource allocation effectively in such a complex environment of IFC systems leads to a fundamental shift from the traditional centralized mechanism toward distributed approaches. Recently, matching theory has emerged as a promising technique for resource allocation problems in many applications, which can alleviate the shortcomings of game theory and optimization-based approaches. Alternatively, while the optimization and game theory based solutions are efficient in a some limited scenarios, the matching-based approaches have potential advantages owing to the distributed and low computational complexity algorithm. However, to reap the benefits of matching theory for task offloading and resource allocation in fog environment there is a need of advanced frameworks to handle their intrinsic properties such as heterogeneity of fog computing devices as well as the novel QoS demands of future generation systems. This directly expose new challenges and associated open issues.
In these regards, this paper provides four important contributions as follows.
• An end-to-end model of IFC system and its associated features such as architecture, computation tasks, computation offloading models, and a generic optimization form of task offloading problems are described to highlight the intrinsic properties of fog-based computing systems.
• The fundamental concept of matching theory and its key models are summarized towards the applications for resource allocation problems.
• The paper emphasizes on reviewing and investigating the proposed matching-based distributed algorithms in the existing literature to solve the computation offloading related problems.
• Remaining challenges and open issues are explored and discussed to provide the future directions of researches and development regarding the usage of matching theory in the new problems and application scenarios. The remainder of this paper is organized as follows. Section II briefly summarizes the key concepts of matching theory including models, classification, and conventional algorithmic solution. Section III reviews the related works that cover existing distributed algorithms without using the matching theory, and the applications of matching theory for resource allocation problems in the wireless networks. Section IV presents the generic models regarding the IFC systems, computational tasks, computation offloading models, and generic optimization problem formulation. Section V discusses and analyzes the matching-based models proposed in the literature to solve the computation offloading problems. Section VI explores the remaining challenges and discusses associated open issues. Section VI concludes the paper.

II. RELATED WORKS
Computation offloading is a pivotal operation in the IoT systems that leverage the edge and fog computing technologies to improve the QoS and QoE. To design efficient offloading algorithms that cope with challenges of fog computing environment and various requirements of services, there are some sort of algorithms and techniques developed in the literature.
In a comprehensive assessment on fog computing architecture and algorithm introduced in [29], the computation offloading process involves three specific problems that are task offloading and load distribution, task scheduling, and resource sharing. The authors evaluate and discuss the proposed algorithms according to the five criteria including heterogeneity, QoS management, scalability, mobility, federation, and interoperability. The algorithms are derived from different approaches such as global optimization, distributed computation, and learning-based methods. However, the most of algorithms do not satisfy all the predefined criteria. For example, the global optimization-based algorithms are no longer to support the scalability requirement owing to its computation complexity in the case of large scale systems.
The work [30] concerns on the optimization models for optimizing the system performance in terms of latency, energy consumption, caching, service placement, and load balancing. Many approaches applied to solve the optimization problems include mix-integer linear programming (MILP), graph theory, game theory, and greedy methods.
Evaluating the distributed computation offloading, the study [18] emphasizes on the locations (i.e., cloud, fog, or local at terminal nodes) where the task offloading is taken place. Accordingly, the algorithms take into account various factors such as task requirements, computation capability of computing nodes, network scale to determine the appropriate locations. The evaluation exposes that the centralized optimization-based algorithms is able to derive the optimal performance of systems, although they suffers from the high computation complexity in the large scale systems. Many distributed and greedy algorithms are investigated, but some of them are efficient in limited application scenarios.
The authors in [31] focus on stochastic-based offloading mechanisms in three major computation environments: mobile cloud computing (MCC), mobile edge computing (MEC), and fog computing (FC). The algorithms are constructed based on the mechanisms following Markov chain, Markov process, and hidden Markov models.
The authors in [32] conduct a comprehensive review of existing literature that applies machine learning for deriving the computation offloading mechanisms in the computing systems. Furthermore, the associated comparative analysis is provided for a comprehensive comparison of stochastic Markov-based offloading mechanisms.
In this work, we conduct a survey of recent offloading algorithms using matching theory that potentially release the shortcomings of aforementioned algorithms by its lightweight and distributed mechanism [33]. To the best of our knowledge, our paper is the first work accessing the state-of-the-art in the matching theory-based algorithms for computational offloading in the IFC systems.

A. BASIC CONCEPT
Matching theory has been considered as a potential mechanism to solve the resource allocation problems in the context of wireless networks [34], [35], [36] since it can alleviate some shortcomings of game theory and optimization-based solutions. Basically, matching theory provides mathematically tractable solutions for the combination problem of matching players in two distinct sets, depending on the individual information and preference of each player. Although the main matching models in the literature deal with two sets of agents, it should be noted that there are matching models that are among the agents in one set only (i.e., stable roommate problem [37]), and matching models among three sets of agents [38], [39].
The basic task offloading problems can be interpreted as a matching problem between the set R of computing resources (R = I ∪ F ∪ C) and the set T of computation tasks. Depending on the scenarios, the resources can be of different abstraction levels, representing base stations, time, power, storage, CPU. Due to the limitation of resource, each fog computing device has a quota that defines the maximum number of players (tasks) with which it can be matched. The main goal of matching is to optimally match resources and tasks given their individual, often different, objectives and exchanged information. Each resource (task) builds a ranking of the tasks (resources) using a preference relation. The concept of preference represents the individual view that each resource or task has of the other set, based on the local information. In its basic form, a preference can simply be defined in terms of an objective utility function that quantifies the QoS achieved by a certain resource-task matching. However, a preference is more generic than a utility function in that it can incorporate additional qualitative measures extracted from the information available to tasks and resource subject the dynamic change of fog computing environment. In the most of works in the literature, the utility function is used to construct the preference lists of agents.
The inherent presence of selfishness and rational of agents prevents the systems to derive a global optimal solution. The objective of matching game is to achieve stability instead of optimality, at which there is no incentive incurred to devise the current matched pairs of agents. The concept of stability is defined differently based on the matching models, which are discussed in the following sections.

B. CLASSIFICATION
There are many variants of matching problems [40]. From the preference list point of view, it distinguishes three types of preference lists including complete, ties, and incomplete PL with ties. Meanwhile, for applying in the resource allocation problem of wireless networks, [41] consider canonical, matching with externalities, matching with dynamics model. Regarding the transfer between two sets of matching game, there are two classes of matching problems: matching with transfer and matching without transfer. In the context of resource allocation for computation offloading in the IFC, another features such as incomplete, ties PL, transfer as well as externatilies are considered to be variants of these matching classes. Regarding the number of sets of player involving the matching, there are three typical types of matching models including one set (i.e., the roommate matching problem), two sets, and three sets (three dimensional matching). In the followings, we discuss the matching models according to three classes of matching game between plays in the two sets.

1) ONE-TO-ONE MATCHING
The most prominent model of one-to-one matching is marriage model. In this model, there is two distinct sets of agents represented by X = {x 1 , x 2 , . . . , x n } and Y = {y 1 , y 2 , . . . ., y k }, respectively. Each agent has a complete preference list over the agents on the other side. Assume that an agent x ∈ X has a preference list P(x) = {y 2 , y 4 , x, y 1 , y 3 , . . .}. This means that x prefers agent y 2 to y 4 and prefers remaining single (x) over matching with y 1 or y 3 . Denote y i x y j to express that an agent x prefers agent y i to y j . In particular, as y i x y j there exists a tie in the preference list of agent x.
The one-to-one matching model is defined as follow: Definition 1: The outcome of one-to-one matching model is a matching M: X ∪ Y → X ∪ Y such that the three following constraints are satisfied: In the one-to-one matching model, each agent x can only be matched with one agent y, and x remains unmatched if M(x) = x. The objective of matching is to reach the stable status for all pairs. Definition 2: A matching M is pairwise stable if there is no block pair (x, y). Definition 3: (x, y) is a block pair for a matching M if three following conditions are satisfied:

2) MANY-TO-ONE MATCHING
In the many-to-one (or one-to-many) matching modes, each agent of one side can be matched with multiple agents of the other side but the reverse is not valid. Similar to one-toone matching, P(x) = {y 1 , y 2 , x, y 4 , y 5 , . . .} illustrates that agent x prefers y 1 to y 2 (y 1 x y 2 ), and prefers keeping the position unfilled over other people like y 4 and y 5 . Unlike one-to-one matching, each agent y has a positive quota q y to represent the maximum number of agents in the set Y it can be matched with. Generally, many-to-one matching can be defined as follow: Definition 4: The outcome of many-to-one matching model is a matching M: X ∪ Y → X ∪ Y such that the three following constraints are satisfied: • |M(y)| = q y for every agent y ∈ Y; if the number of agents in M(y) is k and k < q y , then M(y) will have q y − k copies of y, • M(y) = x if and only if x is an element of M(y). With this definition, M(x) = y means that agent x is matched with agent y, and M(y) = {x 1 , x 2 , y, y} indicates that the agent y with the quota q y = 4 has been matched with two agents x 1 and x 2 and has two unfilled matching positions. The objective of many-to-one matching is to obtain the stable matching, which is defied in the same way as oneto-one matching.

3) MANY-TO-MANY MATCHING
In the models of many-to-many matching, the number of matchings for the agents on the both sides are not restricted to one. Denote q x and q y as the respective quotas for agents x ∈ X and y ∈ Y. Generally, the many-to-many matching is defined as follows: Definition 5: The outcome of many-to-many matching model is a matching M: X ∪ Y → X ∪ Y such that the three following constraints are satisfied: • |M(y)| = q y for every agent y ∈ Y; if the number of agents in M(y) is m and m < q y , then M(y) will have q y − m copies of y, • M(y) = x if and only if x is an element of M(y).

C. CONVENTIONAL ALGORITHMIC SOLUTION
The basic algorithm known as the deferred acceptance (DA) was introduced firstly in [42] to find the one-to-one stable matching for the marriage problem. This algorithm can reach the convergence in the polynomial time for the one-toone matching problems, and very fast for the many-to-one matching models. Fundamentally, DA is an iterative method over the players of sets, in which one side proposes and the other side decides to reject or accept the proposal based on PLs. With this approach, DA is completely distributed since the play is just based on the local information for deriving the decisions. Algorithm 1 shows the key procedures to implement the DA algorithm to achieve the outcome for the one-to-one matching problem. Notably, we consider a complete, strict, and transitive PLs. In addition, the number of agents of both sets are equal, thus at the stability of matching outcome, all agents are matched. The variants such as tie, incomplete PLs, or unequal cardinality of sets are modified according to the application scenarios, which are discussed additionally in the next survey section.

IV. SYSTEM AND OFFLOADING PROBLEM DESCRIPTION
A. SYSTEM MODEL A general IFC system with three-tier architecture is illustrated as in Fig. 1. The system consists of three layer: IoT, fog, and cloud, which are connected by LAN, and WAN to provide  various services for IoT-connected users such as computing, caching, storage, and networking services.
The IoT layer is recorded by a set I = {d 1 , d 2 , . . . , d |I| } of IoT devices, which generate computation tasks recorded in a set T . . , C |C| } represent the sets of fog devices, and cloud servers, respectively. In practical applications, the fog devices are grouped into clusters, each provides a set of specific IoT applications for the end users. And in the large-scale IFC systems, there are multiple domains of fogs, which are federated for jointly process and offload the computation tasks. The fogs in each domain are deployed in a distributed manner. In some scenarios, there is a presence of centralized fog controllers such as fog service providers to manage the fog resources in the domains as well as the security related issues. The fog computing devices are characterized by heterogeneity in terms of computing, networking, and storage capacity depending on device types. Practically, the typical fog devices deployed in the IFC systems include networking devices such as gateways, switches, routers, and a few to name. In many scenarios, the cloudlets [43] and micro data centers (mDCs) [44], [45] are added to the fog domains to enhance the computing capability as mini-servers. Basically, the cloudlets and mDCs are resource-rich devices, which are located in a one-hop proximity of end users or mobile devices (MDs) for improving the QoS of mobile applications. Table 1 shows an example of resource states of fog computing devices with respect to memory capacity of queue buffer (M), CPU frequency (f), and CPU processing density (γ ).
In the cloud tiers, virtual machines (VC) are deployed in the data centers and servers to flexibly provide the services requested by lower layers (i.e., IoT and fog layer).
For the sake of clarity, Table 2 provides notions and abbreviations used mostly in the paper.

B. COMPUTATIONAL TASKS
Each computing task T k can be described with a tuple T k = A k , O k , B k , D k , where A k and O k represent the input and output data size (bits) of task, and B k is the computational resource demands (CPU/GPU cycles) to execute the task. In many application scenarios, there are latency-sensitive tasks, which require to be completely executed within the prescribed deadlines D k .
Basically, A k can include following features: total size (in bits or bytes), splittable or non-splitable, number of data types. The sizes of input data of tasks can be ranged from kilo-bytes to tera-bytes depending the specific applications [46]. Based on this feature, the tasks can be classified into light, medium, and heavy tasks as studied in many of existing works [15], [47] for further analyzing the impact of task sizes on the performance of computation offloading approaches.
The divisibility of tasks, particularly heavy tasks with large input data sizes is also investigated in the offloading cases. Accordingly, the whole input data of a task is definitely processed by a single computing device (e.g., FN, cloud, or even powerful IoT node) as it is unable to be splitted into data subsets. Whereas, in several scenarios, a single task can be divided into multiple subtasks with smaller data sizes. Such the task division is employed to get benefit from parallel computing since the substasks can be processed by different devices simultaneously.
A task can also be partitioned into subtasks based on the types of input data. For example, a typical AI and ML task may include multiple types of data such as text, image, video, and audio as studied in [19] and [48]. This partition is suitable for designing the efficient resource allocations in heterogeneous computing environments, in which there are limited number of devices able to handle the all data types. In other words, some devices only process text-type data, some are capable to process video-type data, and so on. Regarding the resources needed for computation offloading operations, there are many attributes included in B k to process the task. Some of existing works just only consider B k as the number of central processing units (CPU cycles) [25]. In another scenarios, GPU and memory requirements are considered during resource allocation for executing heavy and complex tasks such as the AI, and ML ones [49].

C. COMPUTATIONAL OFFLOADING MODELS
There are many models introduced in the literature to perform the computational offloading operations in the IFC systems. Depending on the application scenarios, the models are established appropriately to support the systems to achieve a single objective or multiple objectives simultaneously such as minimization of total energy consumption, minimization of offloading delay, and maximization of resource utilization, and fairness and balance of workload. Fundamentally, an offloading model takes into account multiple factors including the system architecture, the task properties to derive efficient algorithms, that determine offloading locations, times to offload, and how a task is offloaded (how data of task is handled). In the following paragraphs, we summarize and discuss these relevant aspects to highlight the key features of popular offloading models in the literature.
Regarding the offloading locations, there are two major classes of offloading models including intra-layer and interlayer offloading. The former refers to models that the offloading operations take place in the same layer, whereas the later involve multiple layers (e.g., between IoT and fog layer, between fog and cloud). Concretely, the computational offloading processes can take place only within a stratum of IFC systems where the computing devices in the same tier (e.g., the IoT, fog, and cloud tier) can share their available resources to handle the tasks cooperatively. Recently, the advance of technologies can equip with modern IoT devices more features regarding powerful resource, computing capability to process tasks locally. In combination with the emergence of device-to-device (D2D) communication technologies, the computational offloading between IoT devices is pervasive in the future IFC systems. In the same sense, the tasks can be offloaded within the fog layer and cloud layer, mainly to balance the workload as well as improve the resource utilization [50]. However, the heterogeneity of FN types exposes a challenge of communication between them. It requires unified middlewares and protocols to enable fogto-fog communication and collaboration such as FRAMES developed in [51] to jointly offloading the tasks. Otherwise, FNs can communicate via a centralized agent such as FSP or brokers in their fog domains.
In most of application scenarios, the offloading processes involve multiple layers. For example, as per [15], a task generated by an IoT device can be processed by itself locally or offload to a FN or the cloud finally. The associated analysis reveals that the offloading locations for tasks should be flexible with respect to the task type to get the benefit of offloading operations. Concretely, the heavy tasks should be offloaded to the cloud tier, while the medium tasks are processed by FNs. In addition, the light tasks can be computed locally by IoT devices if they have sufficient resource or offloaded to FNs, otherwise. As the tasks can be splittable, one part of task can be processed by IoT node and the other by the fog or cloud. Finally, there exist several application scenarios, in which the upper layers require the lower layers to execute the task. Theses uncommon offloading models include cloud offloading to fog/IoT and end user devices, fog offloading to the IoT and end user devices for specific purposes of applications [18].
The determination of times to offload tasks is an important aspect in the offloading models. Generally, offloading is needed when TNs are unable to process the tasks locally, or processing them may not satisfy the QoS requirements. Although the modern IoT devices and end user equipment can process some types of tasks locally, the majority of tasks (e.g., complex and heavy tasks, and sporadic tasks emergency cases) generated in the IoT layer are offloaded to the upper layers. However, the task offloading incurs additional cost such as communication delay and energy consumption. Therefore, the offloading model requires an inclusion of mechanism to monitor the system performance, traffic flow rates, network conditions that can support to make the offloading decisions appropriately. For example, the FOGPLAN framework in [22] can provide the dynamic offloading strategies to adapt to the dynamic change of QoS requirements. By observing and analyzing the task processing queue of FNs constantly, tasks currently resided in the processing queues of these FNs must be offloaded to HNs if the predicted processing delays are no longer to meet the deadlines of tasks. The network reliability is also concerned in the fog networks since it directly impacts on the communication delay of offloading processes [21].
The offloading models also specify how the input data of tasks is offloaded and processed. Generally, a full offloading method is applied for a task when its whole data is indivisible and processed by a single HN. Conversely, as a divisibility of task is enabled, a partial offloading scheme can be used to offload a fractional part of task to HNs while the other part of task is processed locally by TN. In the most of studies, a task is assumed to be decomposed into two subtasks, thus there needs only one HN to offload the subtask. As the subtasks are totally independent, the task division is an effective technique employed in the offloading models to cope with the heterogeneity of computing device resources, and simultaneously improve the performance of computing operations. For example, according to the FEMTO model in the work [52], each task is divided into two subtasks with different data sizes, which are then processed by the IoT node and offloaded to the fog entity respectively. This method contributes to minimizing the energy consumption of task offloading while achieving the workload fair among the fog nodes and satisfying the deadline constraints of tasks. Similarly, the partial offloading is utilized in the task offloading models for the heterogeneous fog networks to reduce the task execution delay [26]. Dividing a task into multiple (more than two) subtasks is also considered in [48] to exploit the parallel computation of subtasks at different FNs. As analyzed in [26], compared to the full offloading model, the partial offloading offers more advantages in terms of delay reduction, energy saving, resource utilization, and workload balancing. The independence of subtasks enabling the parallel processing of subtasks is obviously a key to achieve these advantage. However, in practice, some or all subtasks of a tasks can exist a data dependency relation. For example, the output of a subtask can be an input data for another subtask. Thus, completing the task requires a subtask scheduling plan to with respect to the subtak processing order. This in turn can impact the performance of partial offloading models. For instance, as evaluated and analyzed in [48], a number of subtasks for a task can be optimized depending on the system context. In addition, not all tasks A dynamic computational offloading model is proposed in [48] that integrates partial and full offloading to balance the workload in the fog layer. The full offloading plan is used for task T 3 , while the subtasks T 11 of T 1 , subtasks T 21 and T 22 of T 2 are offloaded partially by F 1 , F 2 and F 3 respectively. T 4 is processed locally by F 0 .
should be divided because more subtasks can probably lead to a coupling resource problem. An offloading framework in FRATO is then introduced based on many factors such as the FN resource status (e.g., queue status, computing capability), task request rates, and task properties (e.g., divisibility) to offer a dynamic offloading policy. As illustrated in Fig. 2, FRATO dynamically applies the partial offloading and full offloading modes for the tasks based on the queue status of FNs. In this way, FRATO is able to significantly reduce the offloading delay as well as improving the resource utilization, especially in cases of high rate of task requests. A similar investigation is presented in [51] that considers three models of task processing, in which the subtasks can be executed in sequential, parallel, and mixed processing order.

D. OPTIMIZATION PROBLEMS OF COMPUTATIONAL OFFLOADING
Denote C = {C i , C j , C k , . . .} as the set of objective functions, established by individual computing nodes (i.e., IoT nodes, FNs, or clouds) and by the system for the computational offloading performance at a given time. Some of typical objective functions concerned in the literature include total consumption energy, average task execution delay, total payment cost of resource usage, fairness and workload balancing index, and outage probability. Moreover, there also present objective functions of individual resources to indicate the inherent selfishness and rational of HNs. These kinds of objective functions are referred to as utility ones, which correspond to the benefits and revenues of available resource provision. Summarily, the generic optimization problem in the IFC systems can be represented in the following form: Depending on the application scenarios, the problem P can be in form of single or multi-objective model. Regardless the ultimate objectives of problems, the constraints involve the resource competition, resource limitations, and task scheduling. Concretely, a HN can receive multiple requests for task offloading. However, a certain number of requests are accepted to be processed owing to the limitation of resource such as limited buffer capacity, low residual energy. Furthermore, scheduling the tasks in HNs is considered to respect to the QoS requirements. From the global point of view, the problem becomes a combinatorial problem, which is proven to be NP-hard due to the natural presence of coupling resource problems [53]. Therefore, achieving the globally optimized solution is infeasible, especially in the large-scale systems. In addition, there is an extensive cost of overhead to collect the global information. These issues urge the need to design the distributed algorithms to support the computational offloading processes efficiently.

V. MATCHING-BASED MODELS FOR COMPUTATION OFFLOADING PROBLEMS
Many models and associated algorithms have been proposed to support distributed computation offloading processes in the fog-based environment. In the following, we review them according to the different types of matching models (i.e., oneto-one, one-to-many, and many-to-many) described in the previous section.

A. ONE-TO-ONE MATCHING
A task assignment problem is formulated in [54] to describe the computation offloading in vehicular fog networks (VFNs). In these networks, vehicles with available computing resources can act as vehicle FNs to offload tasks of user equipment (UEs); hence contributing to a reduction of overload on the base station (BS) during the peak time as well as improve QoS or QoE (e.g., delay). Given that sharing resources is conditioned naturally in the context of VFNs, a contract-based incentive mechanism is proposed to promote FNs to perform task offloading. Due to the heterogeneity of resource states, FNs are classified into a set of types, each has different contract item (i.e., reward) formulated by the BS. Considering the task offloading in a certain time slot, each UE has a task that must be offloaded by a certain FN; hence the task assignment problem in this context is treated as a one-to-one matching game. In addition, UEs rank the vehicles by using a preference function G that encapsulates the delay performance and resource pricing. Accordingly, as a task generated by UE U n is offloaded and processed by a vehicle V m , G n,m is defined by: where D n,m is the total delay of offloading, and P m is the price for using the resource of V m . P m is zero initially, and will increase according to the price rising rule proposed in the price-based stable matching algorithm. The simulation based evaluation and analysis show that the proposed resource allocation and task assignment scheme can achieve sub-optimal performance in terms of social welfare and offloading delay compared with the optimal solutions. Importantly, the matching-based solution offers lower complexity of computation because of the nature distribution of DA algorithm. A one-sided one-to-one matching is applied in [55] to develop a distributed algorithm for task offloading in vehicular fog computing (VFC) environment. In the considered offloading scenario, tasks sent from user vehicles (UVs) can be offloaded either by nearby vehicles with residual resources acted as vehicle fog servers (VFSs) or by the remote edge server through road side units (RSUs). The inherent presence of information uncertainty in the vehicular network typically featured by time-varying state of vehicle-to-vehicle (V2V) channels for offloading, available resources and volatility of VFSs leads to a lack of global information in the server side (i.e., the edge server) to derive the globally optimal offloading solution. The matching theory is used in this situation to provide a stable and efficient alternative. Recall that, in each time slot, a task generated by UV can be offloaded to only one VFS, and each VFS is able to process at most one UV's task; hence the task offloading problem is transformed into one-to-one matching game. In addition, an online learning technique is augmented to cope with the information uncertainty by introducing upper confidence bound (UCB) concept inspired from reinforcement learning techniques. The fundamental of UCB is to estimate the future state based on the historical observations while considering the uncertainty of these data known as confidence bound (CB). Furthermore, to capture the volatility of VFSs, the concepts of occurrence awareness and matching conflict awareness are embedded in CB. Consequently, the authors propose a preference function used by a UV i to rank a certain VFS j at a time slot t, which is defined as where D i,j,t−1 is the historical offloading delay at time slot t − 1, and H j is price for using the resource of VFS j. The simulation analysis demonstrates that the proposed approach can efficiently alleviate the severe impacts of volatility and resource conflict. More importantly, it enables the system to obtain close-to-optimal delay performance compared to the case of global information availability. An integration of Stackelberg game and matching game is formulated in [56] to study the task allocation in three-tier fog networks targeting in the patient health monitoring applications. Periodic tasks (i.e., patient health data analysis) and sporadic tasks (e.g., emergency case) are sent and requested from home agents (HA) to the cloud node (CN). In turn, CN assigns FNs to execute these tasks such that the task deadlines are met. Transfer is considered in this game for the interaction of HAs, CN, and FNs. With this configuration, the objective of system is to maximize the resource utilization while minimizing the outages. From the game perspective, the objective is to maximize the utilities of three players. To achieve these objectives simultaneously, the author divides the problem into three sub-problems. Accordingly, a pricing model is proposed to optimize the price of per resource unit, thus maximizing the utility of CN. Hence, HAs are based on the prices and the deadline constraint of task to derive the required resources such that it maximize the utilities of HAs. Finally, CN allocates FNs to HAs efficiently to maximize the utility of FN as well as maximizing the resource utilization and minimizing the outages. While the first two sub-problems are solved by Stackelberg game, the last is addressed using the one-to-one matching-based algorithm. The evaluation analysis shows that the proposed matching-based algorithms can handle the sporadic tasks with satisfied deadline compared to the greedy offloading solutions because the tasks are allocated in the more appropriated resources for computing. In addition, the proposed solution also offers an improved resource utilization at the fog computing nodes.

B. MANY-TO-ONE MATCHING
Most of matching-based algorithms are many-to-one types to apply for two distinct sets including the task set T and the computing device set R = I ∪ F ∪ C. With this model, a certain computing node in R can process multiple tasks, thus resulting in a many-to-one matching problem.
Motivated by the emergence of device-to-device communication (D2D) paradigm, modern IoT devices in the IoT networks can share and allocate available resources among themselves to enable interoperability of processes such as sensing and actuation tasks. A roommate matching model is developed in [57] for pairing these IoT nodes, which are deployed in the same fog domain. Based on the state of resources, each device can determine its quota, indicating number of IoT devices it can pair to share the resources. In addition, the utility function accounting for energy consumption and resource pricing cost is established and measured to use in the preference list construction of nodes. The Irvings matching algorithm [58] is applied and refined to endure a stable pairing between IoT devices. In particularly, compared to the pairing model between IoT node with access points (APs), the stable pairings of IoT nodes in the same domain gains more benefits in terms of energy consumption reduction, and resource utilization improvement compared to the random and greedy pairing approaches. Such the benefits are resulted in from the utilization of IoT nodes with available resources, which can take charge as computing nodes to serve tasks appropriately. The matching-based mechanism ensures to construct a stable matching between pairs of IoT nodes as well as pairs of IoT node and AP without resource conflicts.
The work [59] considers the task offloading carried out by a set F of FNs such as APs, routers, switches. The set of IoT nodes in the IoT layer generates a corresponding set T of computation tasks, which belong to different types of IoT applications. Recall that there is a limited number q of tasks VOLUME 10, 2022 offloaded by a certain FN due to the limitation of resource (i.e. computing, buffer storage). Therefore, the task offloading problem can be viewed as a many-to-one matching game between these two sets. According to [59], the agents of sets construct the preference lists based on utility functions, which account for the communication cost, waiting time in queues, and the execution delay of task. Accordingly, the utility of a task t ∈ T is calculated as follow: where D c tf is the communication delay cost required to transmit the task t from the IoT device to the fog node f , and W tf is the expected waiting time in the queue of f before the task is being processed. In the other side, the agent f of computing resource can obtain the utility according the following equation.
where D ex tf is the execution delay to complete the task t by f .
The association of waiting time into the utility function leads to the presence of externalities of matching problem, in which the preference lists of agents can change after a pair is matched. Therefore, the DA-based algorithm requires a cost of overhead resulted in from the exchange of control packets among FNs to adjust the decision makings (i.e., acceptance or rejection of proposals) over iterations. With this approach, the outcome of matching game is to achieve a two-sided exchange-stable (2ES) matching, which handles the externality efficiently. The simulation results show that the proposed algorithm outperforms greedy and random offloading solutions in terms of worst total completion time, mean waiting time per task, mean total time per tasks, and fairness.
The work [60] studies a dynamic task offloading combining the partial and full offloading in the fog-cloud networks to minimize the total energy consumption. In this model, a computation task can be processed locally by TN or offloaded by HN or by the cloud server. In addition, the tasks can be divided into multiple independent subtasks, which can be processed in parallel by HNs and the cloud. Virtually, at a certain time of offloading decision making, the system is modeled by two sets of agents including the set of TNs T and the set H of helpers including HNs and cloud. Each helper H i ∈ H constructs its PL based on a service efficiency (SE) indicating the channel quality (i.e., transmitting data rate) from TNs to it, whereas EE (Energy Efficiency) is used by TNs to rank the agents of helper set. In mathematical form, EE(k, i) = R k,i /P k,i , where R k,i is the CPU computation capability and P k,i is the computation power when a task T i is offloaded by a helper H i . The work then proposes SMETO algorithm based on the DA procedure and the constructed PLs to achieve the one-to-many stable matching between T and H. Evaluated by the simulation analysis, the outcome of matching shows its benefit in reducing significantly the offloading consumption energy compared to the random approach.
A task offloading framework known as METO is presented in [61] aiming to reduce the total energy consumption and overall full offloading delay in the IoT-fog network. In this network model, each IoT device generates a single task, and the resource of each fog node (FN) is represented by a number q of virtual resource units (VRU). In addition, there is no local computing enabled the IoT nodes, thus the tasks are offloaded by the fog nodes. This offloading model leads to a form of one-to-many matching problem between the IoT device set I or the corresponding task set T and the fog node set F, in which q i is the quota of agent F i ∈ F. As considering jointly multiple criteria (i.e., energy consumption minimization and delay minimization) for the offloading decision-making, METO employed a hybrid CRITIC and TOPSIS-based technique to produce the preferences of both sets. CRITIC (criteria importance through inter criteria correlation) is used to evaluate the criteria and determine the weights of resource allocation strategies, whereas TOPSIS (technique for order of preference by similarity to ideal solution) uses these weights for ranking the agents of opposite sets. With this approach, the produced preference lists are strict, complete and transitive, therefore ensuring to obtain the stable matching. Using the simulation-based comparative analysis, METO shows its advantage in reducing the total consumption energy as well as the overall delay compared to the baseline algorithms including ME [59], SMETO [60], and a random resource allocation policy.
Similar to METO, a one-to-many matching model between the task set T and the FN set F is used in [62] to seek for an efficient task offloading algorithm in the IoTfog systems. However, the system considers the presence of fog service providers (SPs), each of which manages the resources of fog nodes in its domain. Consequently, the task offloading problems is transformed into a student project allocation (SPA) game [63], in which IoT devices (or tasks), FNs, and SPs correspond to students, projects, and lectures respectively. To obtain the multi-objectives of system is challenging due to the selfishness and rational of individual agents. Alternatively, while the objective of IoT device is to minimize the offloading delay as well as the consumption energy, SPs aim to maximize the hosting cost and minimize the outages (i.e., number of tasks exceeding the their deadlines). The work further presents a DA-based distributed task offloading algorithm called SPATO to tackle the challenge. In particular, the preference lists of agents are constructed using the analytical hierarchy process (AHP) [64] that accounts for multiple criteria of system wise objectives to obtain the rankings. The simulation results indicate that the proposed algorithms enable the network to achieve a reduced offloading delay and energy consumption as well as minimum outage compared to the random offloading plan and SMETO [60].
In the same consideration of task offloading problem as studied in [62], an efficient offloading algorithm called LETO is proposed in [65], aiming at balancing the workload of FNs. A one-to-many matching model between a task set T and a FN set F with minimum and maximum quotas is formulated to access the impact of resource capability of FNs on the workload distribution strategy. In addition, with respect to the deadlines of tasks, the PLs of TNs and FNs are constructed based on the expected offloading delay and the deadlines, respectively. Basically, t k ∈ T , and D k,i is the total offloading delay if t k is processed by f i . In the other side, where d i is the deadline of t i . The work then introduces a multi-stage deferred acceptance algorithm (MSDA) to achieve the fair and pareto-optimal matching. Based on the simulation analysis, LETO is able to balance the workload of FNs efficiently while minimizing the outages.
The work [47] introduces an algorithm abbreviated by DATS for offloading dispersive tasks in the fog and cloud networks. Given the presence of TNs and helpers (i.e., coalition of FNs and cloud) in the network, the tasks can be processed by either partial or full offloading mode dynamically. In particularly, a task can be splitted into multiple subtasks, which are then processed by different helpers in parallel to reduce the overall task execution delay. DATS incorporates two algorithms to achieve the objective of task offloading minimization, which are progressive computing resource competition (PCRM) and synchronized task scheduling (STS). Concretely, PCRM is a one-to-many matching-based algorithm to yield an efficient resource allocation strategy between task set T and resource set H of helpers. A new index called processing efficiency (PE) is defined to support the production of preference profiles for the helpers. PE encapsulates communication and computation delay to examine the delay-oriented performance of resource allocation strategy. Recall that PE is calculated as follows for fog a FN m and the cloud k when they execute a task T n : where r n,m is data rate from TN n to FN m, η n is processing density of T n , f m is CPU frequency of FN m, and µ n is output-input ratio of T n .
where r t n , r r n are transmitting and receving data rate from TN n to the cloud. Whereas, TNs rank the agents of helpers based on the QoS that helpers can provide. Alternatively, a TN prefers to match with a helper which minimizes the offloading delay. Second, STS algorithm is proposed to optimize the subtask assignment and scheduling for each task given the matching obtained by PCRM. The extensive simulation analysis is conducted to evaluate the performance of DATS under the impact of many factors including task size, quota of helpers, and network bandwidth. Summarily, DATS can significantly reduce the task offloading delay compared to random and greedy offloading policies.
Another one-to-many matching game is modeled in [66] for assigning the fog resources to serve the requests sent from the end users (EUs) in the IoT networks. Considering the minimum and maximum quotas of FNs (i.e., the minimum and maximum number of EUs that a fog can serve), a multistage differed acceptance (MSDA) algorithm is developed to adjust the resource allocation strategies to reach the stable matching. EUs are based on QoS metrics (i.e., response latency) provided by FNs to derive PLs, whereas FNs take into account the fog load distribution to rank EUs. The outcome of matching allows an efficient assignment, which minimize the delay experienced by users while balancing the load of FNs as compared to the random and greedy resource allocation approaches.
A problem of allocation of FSPs to IoT devices is studied in [67]. Taking into account the heterogeneity of system, the IoT devices are assumed to have different services requested periodically. Likewise, FSPs vary in terms of services that they can provide. This configuration is equivalent to a manyto-one matching model, where some FSPs can serve multiple IoT devices. In particular, incomplete PLs with ties are produced by the agents of both sides. That is because some FSPs are absent in the PL of a certain IoT node if they have no services being requested by the IoT node. Meanwhile, some IoT nodes may have the same raking positions in a PL of a certain FN if they requests the same services. Furthermore, the service access time duration (i.e., long or short) is restricted by FSPs. A truthful and Pareto optimal mechanism is employed to achieve the stability of matching. Through the achieved matching, the SPs can allow short or long access to IoT devices efficiently to use the non-money services respecting to deadlines of tasks. In addition, compared to the random allocation strategy, the proposed approach enables to achieve the maximized best allocation, in which the maximum number of IoT devices are served by the best FSPs in their PLs.
Considering the provision of content and services in the fog-based system, the works [68], [69] employ the one-tomany matching model to formulate the resource allocation problem. The requests sent from EUs are handled by FNs or cloud server depending on type of requests (i.e., content retrieval or computing). The caching technology is employed in the fog layer to accelerate the data and service access for EUs. In the form of two-sided matching game, EUs and FNs construct their PLs based on different preference functions. Concretely, an EU ranks a FN the best if it can provide the content and service with the minimum latency. Meanwhile, a FN prefers to serve the request of EU with minimum energy consumption incurred. Based on simulation analysis, the proposed algorithm demonstrates its benefit when improving the cache hit ratio, reducing the energy consumption, and service response delay. VOLUME 10, 2022 Similar to [66], the work [70] introduced a FoGMatch framework to perform the task scheduling in the IoT-Fog network. In the absence of cloud servers, FNs are responsible to receive and process the tasks requested from the IoT devices. In addition, the limitation of fog resources in terms of CPU and RAM allows a certain number of tasks processed by a single fog at a scheduling interval. With this system configuration, the one-to-many matching game between the IoT set and FN set is applied model and study the resource allocation problem in the fog stratum. Link quality (i.e., data rate) and required resource for computing are two measurements used by the IoT nodes and FNs respectively to rank the agents in the opposite sets. In other words, an IoT node i ranks a FN j the best if the data rate from TN i to FN j is the highest and FN has the maximum available resource. In other side, a FN prefers to serve a task if executing it consumes the largest amount of available resource. Compared to Min-Min and Max-Min optimal scheduling approaches, FoGMatch shows its advantage in improving the makespan of IoT service execution, and resource utilization of FNs.
The work [71] focuses on minimizing the total energy consumption during computation offloading processes for cache-enabled F-RANs. In the considered system, all task requests are sent from UEs to the centralized cloud through FAPs. Then, the cloud is responsible for deciding simultaneously EU-FAP association and task offloading strategies (i.e., which tasks are processed by FAPs, cloud) to achieve the systematic objective. Recall that the objective is constrained by the resource limitation of FAPs (i.e, computing, storage) and deadlines of tasks. By modeling the UE-FAP association problem as a one-to-many matching game, a greedy algorithm based on the DA procedure is designed. PLs of agents of both sides are con constructed based on energy consumption measurement. Hence, a swap matching condition is introduced as a constraint to evaluate the stability of matching. The work further proved that the proposed algorithm can achieve the stable matching when there is no presence of blocking pair or swap matching in the outcome of matching game. Through evaluating the algorithm by simulation approaches, the results show that consumed energy of network can be reduce significantly through efficient and stable EU-FAP association, thus enabling the green F-RANs.
A one-to-many matching game is established to model the association problem of fog network, in which each IoT node (user) can be associated with only a cloudlet while a cloudlet can have multiple IoT nodes matched with it [72]. However, there a limited number of IoT nodes connecting to a cloudlet to respect its maximal workload. In addition, the presence of wireless interference between IoT nodes located in proximity regions when connecting wirelessly to the cloudlets indicate external effect in the matching game. This externality makes PLs of agents change whenever a pair of IoT node and cloudlet is matched. The work introduces a concept called swap matching to handle externalities and then achieve the stable matching outcome. The extensive simulation are provided to show the benefits of proposed algorithms, that include the latency minimization and throughput enhancement compared to the random association approach.
The work [73] concerns the joint optimization problem of radio and computational resource allocation in the IoT-Fog computing systems to optimize the system performance in terms of service delay, user satisfaction, and system cost. Such the problem involves three entities including the set of IoT EUs, FNs, and CSPs (which manage the resources of FNs). From the matching perspective, the mutual interaction of these sets can be modeled in a SPA problem since they corresponds to students, projects, and lectures respectively. To handle the external effect, a procedure called user-oriented cooperation (OUC) is developed. Fundamentally, OUC is a strategy to remove possible blocking pairs in the matching given the presence of externality by swap operations, which evaluate the change of utility values of agents. As a swap is applied for any two current pairs, and the corresponding utility values are changeable, the two pairs is considered as blocking ones. With this way, the proposed algorithm can achieve the stable matching with an addition cost of computation complexity resulted in from the swap operations. Regarding the performance, the simulation results show that the proposed framework enables the system to achieve low service latency as well as minimized outages.
A two-sided matching model is proposed [74] for data stream processing. Applying the micro-services to server the DAG-based stream processing applications, the matching is configured to allocate the micro-services to fog and cloud computing resource. Regarding the preference relation construction, the micro-service ranks the resources based on their processing time. In addition, the resources rank the miro-service according to their residual bandwidth. The stable matching achieved by the DA algorithm offers the mutual benefits for two sides (i.e., micro-service side and resource side). The simulation results demonstrate that the proposed matching mechanism can help the system to reduce significant processing time of stream while lowing the total stream traffic traversed through the fog-fog and fog-cloud paths.

C. MANY-TO-MANY MATCHING
The work [75] integrates the Stackelberg game and matching game to study the computing resource allocation problem in three-tier IoT fog networks. The considered network consists of multiple clusters, each includes a set of FNs and is managed by a centralized data service operator (DSO). These FNs are responsible to provide resources to serve the services requested by data service subscribers (DSSs) such as mobile phones, and IoT devices such that QoS in terms of service delay is satisfied. The work first models the interaction of DSOs and DSSs as a Stackelberg game, in which DSOs are leaders and DSSs are followers. Based on the resource price announced by the leaders, the followers can optimize the resource amount measured by number of CRBs required to achieve the desired QoS. When the optimal resources demanded by DSSs are determined, the framework is to come to resource allocation problems. Given the determined CRBs and the available resources of FNs, the many-tomany matching game is applied to model the interaction of DSOs and FNs. Finally, for each cluster of FNs owned by a DSO, the resource allocation is investigate to assign appropriate CRBs of FNs to serve the requests of DSSs. This problem is modeled as a many-to-many matching game, which aims at maximizing the utility values of FNs and DSSs. The performance of framework is evaluated by simulation scenarios, which further show that the proposed approach is able to maximize the utility of all entities (i.e., DSOs, DSSs, and FNs) while satisfying the QoS demanded by DSSs.
The work [76] studies the problem of placement of virtual functions (VFs) on FNs such that they can serve IoT applications with maximal QoS (i.e., minimized worst application time and outage probability). In this considered scenario, VFs are referred to as software, middle ware that can perform the computation, storage, and networking tasks. In addition, each application is composed by a set of atomic services (i.e., tasks), which must be processed in sequential order (i.e., chain) such as following a sense-process-actual workflow. A many-to-many matching game is applied to model the placement problem of a set of VF types (V) on a set of FNs (F). Concretely, a FN can contain multiple types of VFs depending on the available resource of FN represented by computing resource blocks (CRBs), and each VF type can appear in different FNs. The work then introduces two utility functions for the agents of both sets to support the creation of PLs. In the side of VF set, the utility function U z (f ) of a VF z ∈ V is formulated as follow when placed on a FN f .
where r f is the available CRBs on FN f and r z is the number of CRBs required to load the VF z on the FN f . Based on this function, the order for any two FN f and f in the PL of VF z is as follow: f z f ⇔ U z (f ) < U z (f ). In the other side, the utility function U f (z) of FN f takes into account the occurrence probability of VF z that appears in the FN set.
Accordingly, U f (z) is calculated by: where h z is the occurrence frequency of VF z in the IoT application set A, τ f ,z = 1 if v z is placed on FN f ; otherwise τ f ,z = 0, and n is the total number of types of VFs in the network. Based on this utility function, the preference relation of two certain VF z and z ranked by FN f as follow: z f z . In other words, FNs prefer to allocate VFs such that they have higher values of occurrence frequency in the set A [76]. With this PL construction, the work applies the DA procedure to sketch out the distributed VF placement algorithm named blind matching game (BMG). Additional analysis is provided to show that the proposed algorithm can lead to a stability convergence, at which the outcome of matching game is in form of strictly-twosided exchange-stability (S2ES). Alternatively, there is no existence of blocking pair or swap matching which can break the current matching pair to change positively the utility values of agents. Consequently, at the stability, BMG can achieve a sub-optimal performance in terms of minimization of the work application completion time and the outages.
In addition, it also outperforms other baseline algorithms including the random and greedy offloading approaches. A recent study as per [77] investigates the data offloading problem in the fog network, in which FNs are responsible for receiving and then processing the data periodically transmitted by the subscribed IoT devices. Given the heterogeneity of FN resource, FNs can be classified into two sets: S of surplus FNs (SFNs) and D of deficit FNs (DFNs). As these definitions, SFNs have available resources for data processing, while DFNs are characterized by the lack of resource for handling the requests of their subscribers. In addition, each FN is managed and owned by an unique FSP, thus leading to the nature of selfish and rational, indicating that it tends to maximize the its own profit without considering the system wise performance maximization. The objective focused in the paper is to design an efficient offloading policy such that it can maximize the monetization of FNs subject to the required QoS. To achieve the objective, a matching-based algorithm is proposed that model the interaction of SFNs and DFNs as a many-to-many matching game without quotas. In this game, the agents of both sets produces their PLs based on their own utility functions. For each pair of FNs (f s ∈ S, f d ∈ D), their utility functions are formulated as follow if they match.
Similarly, for two SFNs f s and f s , Based on these PLs, the proposed DA based algorithm is designed to achieve for a stable matching. The analysis is provided to prove its stability convergence, thus ensuring the feasibility and efficiency of algorithm. The primary simulation results show that the proposed algorithm is able to maximize the monetization while satisfying the demanded QoS of the subscriber users (i.e., total latency of data packer processing).

VI. CHALLENGES AND OPEN RESEARCH ISSUES
The review as discussed in the previous section exposes the potential of matching theory in solving the computational offloading problems in the distributed manner. Many models and algorithms have been introduced to apply for different computing scenarios. However, there still exist several challenges appeared in new context of IFC systems. These section explores and investigate such issues. The associated research directions also are included to discuss the full potential of matching theory to address the issues.

A. MATCHING WITH DYNAMICS
In many application scenarios, the matching model should consider the dynamic of environment such as the mobility of fog devices, time-varying tasks. In these contexts, the preferences of agents might change accordingly at each time scheduling interval. Consequently, the time dimension must be accounted for in designing the matching solution.

B. MATCHING WITH GROUPS
In many scenarios, a group of players of a set prefers to match with a single agent of the other set. For example, a groups of tasks with the same type should be processed by fog devices supporting to process this type specially. That will lead to the task placement problem.
A similar issue might also appear in the federated fog based systems, where many domains (clusters) of fog networks are connected and a groups of IoT nodes in a certain domain prefers to be processed by the fog networks of other domain.

C. MATCHING WITH EXTERNALALITY
The nature of resource competition in the computing environment potentially leads to externalities in the matching problem, which are not investigated widely in the existing literature. The interference is only a factor making the continuous change of PLs of agent [78] in the fog and edge computing environment. For example, in the many-to-one matching model, the scheduling of tasks at a single fog can be served as an external that impact on the consistence of PLs. To the best of our knowledge, there has been no research works in the literature considering this kind of externalities in modeling the matching problems and designing the matching-based algorithms.
The presence of sporadic tasks is added as an external source since it can make the task scheduling plan change. In some scenarios, it can be addressed by offloading these tasks to the cloud. However, as the the clouded-based solution is inappropriate, FNs are considered to be alternatives to process the offloaded tasks. This situation may result in a change of PLs of some agents since the scheduled tasks must be postponed.
There are additional sources acting as externalities in may contexts of computing systems. Common ones include the system fault, network unreliability, which directly impact on the task offloading operations. Equivalently, PLs are immediately changed in these contexts because, for example, some HNs in the PLs are inaccessible. Thereby, there requires matching models that take into account these situation to enable the system reconfigure responsively.

D. SECURITY AND PRIVACY OF DATA AND END USERS
The heterogeneity and distributed nature of fog computing environment poses potential risks regarding security and privacy of data and EUs. Therefore, the choice of offloading locations is not only to achieve the improved performance but also guarantee reliability, security, and privacy criteria. This aspect has been not considered during constructing PLs in the reviewed studies, that, in other hand, open future directions.

E. NEW OFFLOADING APPLICATION SCENARIOS
All the reviewed works consider that the computation tasks can be totally processed in either parallel or serial manner. In many practical applications, the computation tasks is more complicated such as DAG tasks (Directed Arched Graph), which require a complex framework for scheduling since there exist parallel and serial computation processes [79]. Typical DAG tasks are related to the modern AI and ML applications such as real-time video processing [80], and automation in the industrial internet [81]. The presence of scheduling complexity can be considered as an external effect impacting directly on the consistence of PLs of agents.

F. APPLICATION OF AI AND ML-BASED TECHNIQUES
AI and ML tools provide efficient techniques to analyze and predict the statues of system accurately. Reinforcement learning is a such kind of techniques [82], [83], which can help to build PLs efficiently through online learning mechanism (i.e., exploitation and exploration). Thus, using these in the context of computational offloading enable the system to make dynamic and efficient offloading decisions. In addition, deep learning (DL) can be used to approximate and examine the matching outcomes [84].

VII. CONCLUSION
The matching theory has been widely applied to offer distributed algorithms in scenarios, where the optimal solutions are infeasible or feasible with incurring expensive expenditure and high computation complexity by the centralized global optimization approaches. The intrinsic feature of architecture of the IFC systems characterized by a geographic distribution of computing devices over large-scale exposes the suitability of matching-based distributed algorithms for perform the computation offloading and resource allocation-related problem. This paper surveys the literature regarding the matching theory-based solutions for distributed computing offloading in the IFC systems. Based on a brief description of matching theory, related concepts and matching models are identified and differences among them are presented. These different models are used to critically review the application scenarios and algorithms proposed in the existing literature in the area of computational offloading. The remaining challenges and corresponding open issues are discussed thoroughly to motivate research directions.