Glider pilots are confronted with several challenges specific to this kind of flight, the major one being the need to maintain adequate separation from other gliders while still operating theaircraft effectively and safely. In this paper, we present an XR intelligent interface, GlideRX, to help pilots manage traffic awareness and prevent mid-air collisions. It allows for better support of situational awareness with respect to current collision warning systems currently available for gliders. The integration of data readings about surrounding aircraft, coupled with predictive algorithms on their trajectories and directions and a morphable representation of visual aids to help identify threats, enhances the situational awareness of the pilot and the management of risky conditions. We tested GlideRX efficacy and effectiveness through multiple evaluation activities, from a usage scenario to a quantitative task-driven experiment with real pilots in simulated conditions. Results show that GlideRX can effectively support a glider pilot in safely managing their flight during the increasing presence of air traffic. GlideRX is publicly available at: https://github.com/XAIber-lab/GlideRX.

By spreading out computing workloads over multiple levels, the Edge-to-Cloud continuum paradigm improves the performance of applications that are sensitive to latency. However, real-time scheduling is difficult on the Edge computing layer since it consists of a variety of nodes with varying uptime. In this paper, we address this issue by proposing an online and adaptive scheduling algorithm based on a continuous learning Reinforcement Learning. Our algorithm determines each work request individually, optimizing scheduling policies to meet real-time application requirements while taking environmental energy and battery limits into account. We validate the efficacy of our approach in dynamically assigning tasks, particularly in scenarios where Edge nodes exhibit variable speeds and unpredictable failures, while efficiently managing energy resources and battery constraints through extensive simulations and comparisons with static scheduling strategies.

We consider the case of a set of energy harvesting edge nodes, equipped with photovoltaic panels that implement some kind of monitoring service. To ensure that the service operates in an optimal way, nodes have sometimes offload some of their data to other nodes. We show that this kind of task offloading (migration) can improve service performance by avoiding temporary interruptions and prolonging the overall service lifetime. We present a centralized algorithm based on Linear Programming optimization problem solution and a distributed implementation.

When dealing with distributed applications in Edge or Fog computing environments, the service latency that the user experiences at a given node can be considered an indicator of how much the node itself is loaded with respect to the others. Indeed, only considering the average CPU time or the RAM utilisation, for example, does not give a clear depiction of the load situation because these parameters are application- and hardware-agnostic. They do not give any information about how the application is performing from the user's perspective, and they cannot be used for a QoS-oriented load balancing. In this article, we propose a load balancing algorithm that is focused on the service latency with the objective of levelling it across all the nodes in a fully decentralised manner. In this way, no user will experience a worse QoS than the other. By providing a differential model of the system and an adaptive heuristic to find the solution to the problem in real settings, we show both in simulation and in a real-world deployment, based on a cluster of Raspberry Pi boards, that our approach is able to level the service latency among a set of heterogeneous nodes organised in different topologies.

When deploying a distributed application in the Fog or Edge computing environments, the average service latency among all the involved nodes can be an indicator of how much a node is loaded with respect to the other. Indeed, only considering the average CPU time, or the RAM utilisation, for example, does not give a clear depiction of the load situation because these parameters are application- and hardware-agnostic. They do not give any information about how the application is performing from the user perspective and they cannot be used for a QoS-oriented load balancing of the system. Moreover, due to the displacement of the nodes and the heterogeneity of the computing devices the necessity of a load balancing algorithm is clear. In this paper, we propose a load balancing approach that is focused on the service latency with the objective to level it across all the nodes in a fully decentralized manner, in this way no user will experience a worse QoS than the other. By providing a differential model of the system and an adaptive heuristic to find the solution to the problem, we show both in simulation and in a real-world deployment that our approach is able to level the service latency among a set of heterogeneous nodes organized in different topologies.

In this article, we consider a load balancing protocol based on the power of random choices that is adapted to a fog deploy in which several independent fog nodes equipped with a set of servers or VM are serving the same geographical area. The protocol is based on a simple but effective mechanism based on a threshold$T$. When a fog node receives a unit of computation or a job, it immediately executes the job if the number of its occupied servers is lower than$T$, otherwise the node executes a randomized algorithm by probing$F$other fog nodes in the area, and delegates the execution of the job to the least loaded one, provided the workload is lower than the probing node. Through a mathematical analysis we show that probing just one node ($F=1$) when there are less than two free VMs provides the same performance of the well known power-of-two random choices centralized algorithm, but at a much lower delay and control overhead costs. Also, simulations are used to address the node heterogeneity and, with a real testbed, we offer results that prove the effective benefit of the proposed solution in practical applications.

Different libraries allow performing computer vision tasks, e.g., object recognition, in almost every mobile device that has a computing capability. In modern smartphones, such tasks are compute-intensive, energy hungry computation running on the GPU or the particular Machine Learning (ML) processor embedded in the device. Task offloading is a strategy adopted to move compute-intensive tasks and hence their energy consumption to external computers, in the edge network or in the cloud. In this paper, we report an experimental study that measure under different mobile computer vision set-ups the energy reduction when the inference of an image processing is moved to an edge node, and the capability to still meet real-time requirements. In particular, our experiments show that offloading the task - in our case real-time object recognition - to a possible next-to-the-user node allows saving about the 70% of battery consumption while maintaining the same frame rate (fps) that local processing can achieve.

The current computing power of single-board computers (SBCs) is relevant, and if this factor is associated with the very low cost of installing and operating such devices, building a cluster is a natural consequence. Very often in fog computing, researchers need to run and test their distributed solutions and algorithms in real hardware and software, rather than by simulations and doing this in a cluster of SBCs is feasible and inexpensive. This paper addresses most of the problems and issues that arise when building a self-contained, remote controllable and unattended cluster of Raspberry Pi that minimizes the physical intervention of a human operator, which enables the notion of Testbed as-a-Service. The solution envisioned here is to set up the cluster in a desktop computer case, which needs addressing power management and to allow remote configuration of experiments. Moreover, the paper proposes several guidelines for installing a suitable operating system and software for running any kind of distributed application.

In this paper, we propose a distributed resource sharing protocol for distributed peer to peer cooperation among a set of nearby fog nodes, managed by different and competing providers. The protocol is based on the notion of fair cooperation that allows fog nodes to reach optimal resource sharing. We adopt an analytical approach to study the cooperation problem of providers subject to different load conditions. We then report a simulation study that confirms our findings.

The computing continuum model is a widely ac-cepted and used approach that make possible the existence of applications that are very demanding in terms of low latency and high computing power. In this three-layered model, the Fog or Edge layer can be considered as the weak link in the chain, indeed the computing nodes whose compose it are generally heterogeneous and their uptime cannot be compared with the one offered by the Cloud. Taking into account these inexorable characteristics of the continuum, in this paper, we propose a Reinforcement Learning based scheduling algorithm that makes per-job request decisions (online scheduling) and that is able to maintain an acceptable performance specifically targeting real-time applications. Through a series of simulations and comparisons with other fixed scheduling strategies, we demonstrate how the algorithm is capable of deriving the best possible scheduling policy when Fog or Edge nodes have different speeds and can unpredictably fail.

Fog computing infrastructures must support increasingly complex applications where a large number of sensors send data to intermediate fog nodes for processing. As the load in such applications (as in the case of a smart cities scenario) is subject to significant fluctuations both over time and space, load balancing is a fundamental task. In this paper we study a fully distributed algorithm for load balancing based on random probing of the neighbors' status. A qualifying point of our study is considering the impact of delay during the probe phase and analyzing the impact of stale load information. We propose a theoretical model for the loss of correlation between actual load on a node and stale information arriving to the neighbors. Furthermore, we analyze through simulation the performance of the proposed algorithm considering a wide set of parameters and comparing it with an approach from the literature based on random walks. Our analysis points out under which conditions the proposed algorithm can outperform the alternatives.

The fog computing paradigm brings together storage, communication, and computation resources closer to users' end-devices. Therefore, fog servers are deployed at the edge of the network, offering low latency access to users. With the expansion of such fog computing services, different providers will be able to deploy multiple resources within a restricted geographical proximity. In this paper, we investigate an incentive-based cooperation scheme across fog providers. We propose a distributed cooperative algorithm amongst fog computing providers where fully collaborative fog nodes are subject to different loads. The proposed algorithm leverages the power-of-two result and exploits a cooperation probability, namely the probability that a given provider collaborates by accepting a computation request from another provider, as a mean to achieve a fair cooperation. We adopt an analytical approach based on exploiting a simplified performance model to demonstrate numerically that a set of optimal accepting probabilities exits when the number of server nodes goes to infinity. This result then drives the design of our distributed algorithm. Second, in our experimental approach, we perform a set of simulation analysis to verify the validity of the proposed solution when the number of servers is limited.

In this paper, we propose and report a study of a low latency resource sharing protocol for Fog Computing. The protocol has its root in the power-of-random choices family of randomization protocol. The protocol, dubbed LL9(T) is designed to cope with a not homogeneous set of nodes and dealing with a communication latency comparable with the task execution, a characteristic of time-constrained applications supported by this service delivery model. The protocol allows to determine when a task can be moved from the origin fog node that receives the task to another node, where it can be executed faster. This task handoff is controlled via a threshold T. The remote node is selected uniformly at random.

Fog computing is a key paradigm that brings together shared storage, low latency communication, and computation resources closer to users' end-devices. While most IoT services adopt a three-tier computing architecture, where fog nodes are always probed first before reaching a distant Cloud, collaboration across multi-stakeholder, multi-tenant fog providers remains unexplored. In this paper, we quantitatively highlight the gain which may arise if a collaborative fog computing paradigm is deployed. Next, we propose CICO, an incentive based collaborative mechanism for fog computing networks. CICO regulates a multi-stakeholder, multi-tenant cooperation among fog providers. We present a mathematical model and an experimental approach to make the case for such cooperation paradigm.

With the advent of wearable computing and the resulting growth in mobile application market, we investigate mobile opportunistic cloud computing where mobile devices leverage nearby computational resources in order to save execution time and consumed energy. Our goal is to enable generic computation offloading to heterogeneous devices forming a mobile-to-mobile opportunistic computing platform. In this paper, we adopt (1) an analytical approach and (2) an experimental approach to highlight the gain given by mobile-to-mobile opportunistic offloading compared to local execution. We also investigate multiple offloading strategies with regards to both computation time and energy consumption. We propose an auto-splitting and offloading algorithms that computes the optimal chunks sizes that could be offloaded remotely to neighboring mobile device. We show that our splitting and offloading algorithm succeeds in picking the optimal chunk sizes and distribution with up to 99.7% efficiency. In addition, the offloader device saves up to 80% energy while offloading the task remotely. For instance if the offloader device is running out of battery, offloading is the ultimate solution to increase its lifetime.

It is common practice for mobile devices to offload computationally heavy tasks off to a cloud, which has greater computational resources. In this paper, we consider an environment in which computational offloading is made among collaborative mobile devices.We call such an environment a mobile d

The publish/subscribe paradigm is gaining attention for the development of several applications in wide area networks (WANs) due to its intrinsic time, space, and synchronization decoupling properties that meet the scalability and asynchrony requirements of those applications. However, while the communication in a WAN may be affected by the unpredictable behavior of the network, with messages that can be dropped or delayed, existing publish/subscribe solutions pay just a little attention to addressing these issues. On the contrary, applications such as business intelligence, critical infrastructures, and financial services require delivery guarantees with strict temporal deadlines. In this paper, we propose a framework that enforces both reliability and timeliness for publish/subscribe services over WAN. Specifically, we combine two different approaches: gossiping, to retrieve missing packets in case of incomplete information, and network coding, to reduce the number of retransmissions and, consequently, the latency. We provide an analytical model that describes the information recovery capabilities of our algorithm and a simulation-based study, taking into account a real workload from the Air Traffic Control domain, which evidences how the proposed solution is able to ensure reliable event notification over a WAN within a reasonable bounded time window.

We propose an efficient software architecture for private collaborative event processing, enabling information sharing and processing among administratively and geographically disjoint organizations over the Internet. The architecture is capable of aggregating and correlating events coming from the organizations in near real-time, while preserving the privacy of sensitive data items even in the case of coalition of attackers. Although there is a rich literature in the field of secure multiparty computation techniques that preserve the privacy in a distributed systems, the ability of such systems to scale up horizontally (number of participants) and vertically (dataset per participant) is still limited. The key novelty of the architecture is the usage of a pseudo-random oracle functionality distributed among the organizations participating to the system for obfuscating the data, that allows for achieving a good level of privacy while guaranteing scalability in both dimensions. Some preliminary performance results are provided.

Telco providers are in the phase of migrating their services from PSTN to so called Next Generation Networks (NGNs) based on standard IP connectivity. This switch is expected to produce a cost degression of 50% for CAPEX, while OPEX remains fairly stable due to network management and energy costs. At the same time we are expecting a big increase of the load of a telco provider at the core level due to the istantiation of new telco services (VoIP, video conferencing etc) and to the support of third parties services (such as support to smartphone applications, etc.). The goal of this work is to show how management and energy costs can be effectively reduced by leveraging autonomic approaches to move some NGN services toward the telco network edge while still providing QoS levels comparable with those provided by a traditional fully-managed infrastructure.

Random walk (RW) is simple to implement and has a better termination control. The Markov chain analysis informs that RW eventually visits all vertices of a connected graph. Due to such nice properties, RW is often proposed for information dissemination or collection from all or part of a large scale unstructured network. The random walker, which can be used to disseminate or collect information, visits the nodes while selecting randomly one of the neighbors. The selection of neighbors is effected by the neighbor density or the connectivity degree of the nodes. The connectivity degree in turn depends on the radius of transmission of wireless nodes. In this paper we studied the coverage process of the RW on random geometric graph. The random geometric graphs are often considered as a model for wireless ad hoc and sensor networks. We defined and studied a metric called “attenuation” that indicates how fast a RW can move in the network while disseminating or collecting information. We showed that attenuation depends on the topology, the number of nodes in a network and the transmission radius of the nodes. We then studied the effect of attenuation on the RW coverage process analytically and through simulations and showed that attenuation is the normalized estimated search time of the network. In the end we applied the results obtained to show that the estimated search time in random geometric graphs is proportional to the reciprocal of the number of replicated targets.

Low-latency data delivery is an important requirement for achieving effective monitoring through wireless sensor networks. When sensor nodes employ duty cycling, sending a message along the shortest path, however, does not necessarily result in minimum delay. In this paper, we first study the lowest latency path problem, i.e., the characteristics of a path with minimum delay that connects a source node to the sink under random duty cycling nodes. Then, we propose a forwarding protocol based on biased random walks, where nodes only use local information about neighbors and their next active period to make forwarding decisions. We refer to this as lukewarm potato forwarding. Our analytical model and simulation experiments show that it is possible to reduce path latency without significantly increasing the number of transmissions (energy efficiency) needed to deliver the message to the destination. In particular, although deviating from the shortest path requires additional transmissions, and hence, higher energy consumption, this increase is compensated by a lighter duty cycle. Our experiments show that, overall, we can save up to 15 percent of energy while obtaining the same data delivery delay as shortest path routing. Additionally, the proposed solution is tunable. By changing the value of just one threshold parameter, it can be tuned to operate anywhere in the continuum from hot potato/random walk forwarding protocol to a deterministic shortest path forwarding protocol.

Consider a group of peers, an ideal random peer sampling service should return a peer, which is an unbiased independent random sample of the group. This paper focuses on peer sampling service based on view shuffling (aka gossip-based peer sampling), where each peer is equipped with a local view of size c. This view should correspond to a uniform random sample of size c of the whole system in order to implement correctly a uniform peer sampling service. To this aim, pairs of peers regularly and continuously swap a part of their local views (shuffling operation). The paper provides a proof that (i) starting from any non-uniform distribution of peers in the peers' local views, after a sequence of pairwise shuffle operations, each local view eventually represents a uniform sample of size c and (ii) once previous property holds, any successive sequence of shuffle operations does not modify this uniformity property. This paper also presents some numerical results concerning the speed of convergence to uniform samples of the local views.

The last progress in the pervasive computing field has led to the distribution of knowledge and computational power in the environment, rather than condensing it in a single, powerful entity. This allows agents to behave like insects in a swarm, that can fulfil a task communicating directly or indirectly among them. Following this vision of ambient intelligence, our work proposes a straightforward solution to coordinate a swarm of robots that have low computational capabilities. All the information and instructions are found in RFID tags that are used as a pervasive memory distributed in the environment. These robots exploit ubiquitous computing to make a formation in space, synchronise with team mates in the same zone, and finally complete a cooperative task. Before implementing the solution in a real scenario, we show the validation of our algorithm in a simulation environment.

Low latency data delivery is an important requirement for achieving effective monitoring through wireless sensor networks. When sensor nodes employ duty cycling, sending a message along the shortest path, however, does not necessarily result in minimum delay. In this paper we firstly study the lowest latency path problem, i.e., the characteristics of path with mini delay that connect a source node to the sink under random duty cycling nodes. Then, we propose a forwarding protocol based on biased random walks, where nodes only use local information about neighbors and their next active period to make forwarding decisions. We refer to this as lukewarm potato forwarding. Our analytical model and simulation experiments show that it is possible to reduce path latency without significantly increasing the number of transmissions (energy efficiency) needed to deliver the message to the destination. Additionally, the proposed solution is tunable. By changing the value of just one threshold parameter it can be tuned to operate anywhere in the continuum from hot potato/random walk forwarding protocol to a deterministic shortest path forwarding protocol.

A recurrent problem when designing distributed applications is to search for a node with known property. File searching in peer-to-peer (P2P) applications, resource discovery in service-oriented architectures (SOAs), and path discovery in routing can all be cast as a search problem. Random walk-based search algorithms are often suggested for tackling the search problem, especially in very dynamic systems-like mobile wireless networks. The cost and the effectiveness of a random walk-based search algorithm are measured by the excepted number of transmissions required before hitting the target. Hence, to have a low hitting time is a critical goal. This paper studies the effect of biasing random walk toward the target on the hitting time. For a walk running over a network with uniform node distribution, a simple upper bound that connects the hitting time to the bias level is obtained. The key result is that even a modest bias level is able to reduce the hitting time significantly. This paper also proposes a search protocol for mobile wireless networks, whose results are interpreted in the light of the theoretical study. The proposed solution is for unstructured wireless mobile networks.

Abstract Random walks can be conveniently exploited for implementing probabilistic algorithms to solve many searching problems arised by distributed applications, for example, service discovery, p2p file sharing, etc. In this paper we consider random walks executed on uniform wireless networks and study how to reduce the expected number of walk steps required to reach a target, namely the hitting time. The latter is the main search performance metric of a random walk based algorithm, since it determines the average response to a search as well as its cost; thus, the actual convenience of using random walks compared to other solutions depends on achieving a low hitting time. We show how in uniform wireless networks, the natural implementation of a random walk which selects the next node to visit at random among all neighbors is not a good choice, since it has a strong negative effect on the hitting time. This paper studies such a negative effect analytically and proposes two neighbor selection rules aiming at reducing the hitting time. A simulation study confirms the benefits of the proposed solutions. Copyright © 2008 John Wiley & Sons, Ltd.

This paper is about energy efficient and robust implementation of random walks in mobile wireless networks. While random walk based algorithm are often proposed to solve many problems in wireless networks, their implementation is usually done at the application layer so that many characteristics of the wireless transmissions are not exploited. In this paper we show that we can greatly reduce the energy requirements to perform a walk by better exploiting the broadcast nature of the transmissions. We propose a robust, energy efficient distributed next hop selection algorithm. To evaluate the algorithm we present a simulation study performed with ns-2. We found that in the proposed algorithm energy is reduced to more than 4 times and the selection delay is reduced to more than 8 times as compared to a standard next hop selection implementation.

Recently many scalable and efficient solutions for event dissemination in publish/subscribe (pub/sub) systems have appeared in the literature. This dissemination is usually done over an overlay network of brokers and its cost can be measured as the number of messages sent over the overlay to allow the event to reach all intended subscribers. Efficient solutions to this problem are often obtained through smart dissemination algorithms that avoid flooding events on the overlay. In this paper, we propose a complementary approach that obtains efficient event dissemination by reorganizing the overlay network topology. More specifically, this reorganization is done through a self-organizing algorithm executed by brokers whose aim is to directly connect, through overlay links, pairs of brokers matching same events. In this way, on average, the number of brokers involved in an event dissemination decreases, thus reducing its cost. Even though the paradigm of the self-organizing algorithm is general and then applicable to any overlay-based pub/sub system, its concrete implementation depends on the specific system. As a consequence, we studied the effect of the introduction of the self-organizing algorithm in the context of a specific system implementing a tree-based routing strategy, namely SIENA, showing the actual performance benefits through an extensive simulation study. In particular, performance results point out the capacity of the algorithm to converge to an overlay topology accommodating efficient event with respect to (w.r.t) dissemination a specific scenario. Moreover, the algorithm shows a significant capacity to adapt the overlay network topology to continuously changing scenarios while keeping an efficient behavior w.r.t. event dissemination.

Abstract This paper presents a formal framework of a distributed computation based on a publish/subscribe system. The framework abstracts the system through two delays, namely the subscription/unsubscription delay and the diffusion delay. This abstraction allows one to model concurrent execution of publication and subscription operations without waiting for the stability of the system state and to define a Liveness property which gives the conditions for the presence of a notification event in the global history of the system. This formal framework allows us to analytically define a measure of the effectiveness of a publish/subscribe system, which reflects the percentage of notifications guaranteed by the system to subscribers. A simulation study confirms the validity of the analytical measurements. Copyright © 2005 John Wiley & Sons, Ltd.

A publish/subscribe communication system (PSS) realizes a many-to-many anonymous interaction among its participants. Producers of information (publishers) issue notifications to the PSS. These are delivered by the PSS to all subscribers that declared interest in it. However, this decoupled form of interaction introduces delays between i) the production of a notification and its delivery to subscribers (diffusion delay) and ii) the declaration of interest by a subscriber and its registration in the PSS (subscription/unsubscription delay). Such delays could lead to notification loss scenarios where an event is not delivered to an intended subscriber even though it was issued when the subscription was active. We studied this notification loss phenomenon by presenting a simulation study of a PSS and an analytical model. The latter measures the percentage of notifications guaranteed by a PSS implementation to a subscriber. This addresses a QoS issue. The model is based on a formal framework of a distributed computation. The framework abstracts the PSS through the two delays, defining safety and liveness properties that precisely characterize the semantics of the PSS.

A large class of routing protocols for MANETs, namely, reactive protocols employ some form of caching to reduce the number of route discoveries. The simplest form of caching is based on associating a timeout with each cache entry. Such timer-based cache schemes can increase the protocol efficiency. However, if the timeout is not well-tuned, a severe performance degradation arises as entries are removed either too early or too late from the cache. We address the problem of designing a proactive cache scheme that does not rely on any timer-based mechanism. This scheme guarantees that valid cached routes are never removed while stale routes are removed aggressively. This proactive cache scheme has been embedded in the Zone Routing Protocol (ZRP) framework and evaluated by an extensive simulation study.

Communication protocols designed for database applications are not necessarily suitable for other applications, like multimedia communication, due to the former's requirement of reliable and ordered communication, and the latter's ability to withstand occasional losses and misordering of messages as long as real-time communication can be supported. This paper presents the slotted-FIFO communication mode that supports communication primitives for the entire spectrum of reliability and ordering requirements of distributed applications: for example, FIFO as well as non-FIFO, and reliable as well as unreliable communication. It provides communication with a run-time variable degree of reliability and/or ordering. Hence, the slotted-FIFO communication mode is suitable for applications that can work with relaxed reliability and/or ordering constraints such as multimedia applications. The protocol is simple and has low overheads. As FIFO ordering is not required for all messages, message buffering requirements are considerably reduced. Also, message latencies are lower. We demonstrate such advantages by means of a simulation study. A low overhead protocol implementing slotted-FIFO communication is also presented. The protocol incurs a small resequencing cost.

This paper presents the slotted-FIFO communication mode that supports communication primitives for the entire spectrum of reliability and ordering requirements of distributed applications: FIFO as well as non-FIFO, and reliable as well as unreliable communication. Hence, the slotted-FIFO communication mode is suitable for multimedia applications, as well as non real-time distributed applications. As FIFO ordering is not required for all messages, message buffering requirements are considerably reduced. Also, message latencies are lower. We quantify such advantages by means of a simulation study. A low overhead protocol implementing slotted-FIFO communication is also presented. The protocol incurs a small resequencing cost.

Future cellular systems are expected to use multilayered, multisized cells to cover non-homogeneous populated areas. An example in literature is given by a 2 level hierarchical architecture in which an overlaying macrocell provides a group of overflow channels utilized when a microcell, which covers a densely populated area, is not able to accommodate a new call, or a handover from another microcell. The macrocell has the higher hierarchical position, meaning that it can receive handover requests from microcells, lower in the hierarchy, as well as from other macrocells. On the contrary, a call served by the macrocell cannot handover to a microcell. This paper proposes a reversible hierarchical scheme characterized by the presence of handover attempts from macrocells to microcells. The scheme is conceived so that the microcells are given the majority of the traffic load as they are able to operate with very high capacity, while the macrocells, having lower channel utilization, can better carry out their support task. An analytical study is carried out showing that the system performance can be improved, at the expense of relatively little increase of network control overhead, when compared with the classical, i.e. nonreversible hierarchical scheme.