9 results
Now showing1 - 9 of 9
- Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , Context-aware routing in fog computing systems(IEEE, 2021-08-06); ; ; Fog computing enables the execution of IoT applications on compute nodes which reside both in the cloud and at the edge of the network. To achieve this, most fog computing systems route the IoT data on a path which starts at the data source, and goes through various edge and cloud nodes. Each node on this path may accept the data if there are available resources to process this data locally. Otherwise, the data is forwarded to the next node on path. Notably, when the data is forwarded (rather than accepted), the communication latency increases by the delay to reach the next node. To avoid this, we propose a routing mechanism which maintains a history of all nodes that have accepted data of each context in the past. By processing this history, our mechanism sends the data directly to the closest node that tends to accept data of the same context. This lowers the forwarding by nodes on path, and can reduce the communication latency. We evaluate this approach using both prototype- and simulation-based experiments which show reduced communication latency (by up to 23%) and lower number of hops traveled (by up to 73%), compared to a state-of-the-art method.Publicationtype: Journal Article63 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: with files , FogFrame: a framework for IoT application execution in the fogRecently, a multitude of conceptual architectures and theoretical foundations for fog computing have been proposed. Despite this, there is still a lack of concrete frameworks to setup real-world fog landscapes. In this work, we design and implement the fog computing framework FogFrame—a system able to manage and monitor edge and cloud resources in fog landscapes and to execute Internet of Things (IoT) applications. FogFrame provides communication and interaction as well as application management within a fog landscape, namely, decentralized service placement, deployment and execution. For service placement, we formalize a system model, define an objective function and constraints, and solve the problem implementing a greedy algorithm and a genetic algorithm. The framework is evaluated with regard to Quality of Service parameters of IoT applications and the utilization of fog resources using a real-world operational testbed. The evaluation shows that the service placement is adapted according to the demand and the available resources in the fog landscape. The greedy placement leads to the maximum utilization of edge devices keeping at the edge as many services as possible, while the placement based on the genetic algorithm keeps devices from overloads by balancing between the cloud and edge. When comparing edge and cloud deployment, the service deployment time at the edge takes 14% of the deployment time in the cloud. If fog resources are utilized at maximum capacity, and a new application request arrives with the need of certain sensor equipment, service deployment becomes impossible, and the application needs to be delegated to other fog resources. The genetic algorithm allows to better accommodate new applications and keep the utilization of edge devices at about 50% CPU. During the experiments, the framework successfully reacts to runtime events: (i) services are recovered when devices disappear from the fog landscape; (ii) cloud resources and highly utilized devices are released by migrating services to new devices; (iii) and in case of overloads, services are migrated in order to release resources.Publicationtype: Journal ArticleScopus© Citations 6 58 160 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: with files , Distributed algorithms based on proximity for self-organizing fog computing systemsVarious performance benefits such as low latency and high bandwidth have turned fog computing into a well-accepted extension of the cloud computing paradigm. Many fog computing systems have been proposed so far, consisting of distributed compute nodes which are often organized hierarchically in layers. To achieve low latency, these systems commonly rely on the assumption that the nodes of adjacent layers reside close to each other. However, this assumption may not hold in fog computing systems that span over large geographical areas, due to the wide distribution of the nodes. To avoid relying on this assumption, in this paper we design distributed algorithms whereby the compute nodes measure the network proximity to each other, and self-organize into a hierarchical or a flat structure accordingly. Moreover, we implement these algorithms on geographically distributed compute nodes, and we experiment with image processing and smart city use cases. Our results show that compared to alternative methods, the proposed algorithms decrease the communication latency of latency-sensitive processes by 27%–43%, and increase the available network bandwidth by 36%–86%. Furthermore, we analyze the scalability of our algorithms, and we show that a flat structure (i.e., without layers) scales better than the commonly used layered hierarchy due to generating less overhead when the size of the system grows.Publicationtype: Journal ArticleScopus© Citations 17 46 139 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , Towards Extensibility-Aware Scheduling of Industrial Applications on Fog NodesFog computing has been identified as an enabler for many modern technologies like connected vehicles and the Industrial Internet of Things (IIoT). Such technologies are characterized by the integration of applications with different levels of criticality on shared platforms, which are referred to as mixed-criticality systems. Mixed-criticality systems typically use static scheduling for critical tasks; however, static scheduling is not suitable for scenarios where fog nodes run dynamic noncritical applications that implement, e.g., maintenance checks and data analytics. To address this challenge, in this paper, we differentiate between critical tasks that are statically allocated (called 'native') and dynamic non-critical tasks that may migrate across fog nodes (called 'temporary'). We propose a static scheduling approach that maximizes the number of temporary tasks that can be added at runtime, without negatively impacting the already scheduled native tasks. This approach enables fog nodes to become more suitable for IIoT environments by configuring them with extensible schedules for the native tasks. To evaluate our approach, we perform experiments considering several test cases, which show that given a number of native tasks, the generated extensible schedules enable the fog nodes to run a larger number of temporary tasks at the same time. Furthermore, the extensible schedules exhibit 7.8 % less missed deadlines (on averaae), compared to the non-extensible schedules. To address this challenge, in this paper, we differentiate between critical tasks that are statically allocated (called 'native') and dynamic non-critical tasks that may migrate across fog nodes (called 'temporary'). We propose a static scheduling approach that maximizes the number of temporary tasks that can be added at runtime, without negatively impacting the already scheduled native tasks. This approach enables fog nodes to become more suitable for IIoT environments by configuring them with extensible schedules for the native tasks. To evaluate our approach, we perform experiments considering several test cases, which show that given a number of native tasks, the generated extensible schedules enable the fog nodes to run a larger number of temporary tasks at the same time. Furthermore, the extensible schedules exhibit 7.8 % less missed deadlines (on averaae), compared to the non-extensible schedules.Publicationtype: Conference Paper18 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , Comparison of Alternative Architectures in Fog Computing(2020-05); Since the proliferation of fog computing, various distributed architectures have been proposed to extend the cloud to the edge of the network. However, so far there exists no study that compares different fog computing architectures, and produces quantitative results in order to examine the efficiency of each architecture for different use cases. Such a study could provide guidelines for selecting an appropriate distributed architecture for fog computing while taking into account the requirements of the final applications.To bridge this gap in the literature, we create a unified system model which is able to represent the basic architectures commonly used for fog computing, i.e., hierarchical and flat. Furthermore, we design algorithms that can be used for creating fog computing systems that follow these architectures, and we perform various experiments that focus on communication latency and bandwidth utilization. Notably, our results show that for applications that do not have a dependency on the cloud, i.e., no resource-demanding tasks are involved, the hierarchical architecture reduces the communication latency by 13% compared to the flat. However, for applications that also include resource-demanding tasks, the flat architecture reduces the communication latency by 16% compared to the hierarchical.Publicationtype: Conference Paper44 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , Addressing the node discovery problem in fog computingIn recent years, the Internet of Things (IoT) has gained a lot of attention due to connecting various sensor devices with the cloud, in order to enable smart applications such as: smart traffic management, smart houses, and smart grids, among others. Due to the growing popularity of the IoT, the number of Internet-connected devices has increased significantly. As a result, these devices generate a huge amount of network traffic which may lead to bottlenecks, and eventually increase the communication latency with the cloud. To cope with such issues, a new computing paradigm has emerged, namely: fog computing. Fog computing enables computing that spans from the cloud to the edge of the network in order to distribute the computations of the IoT data, and to reduce the communication latency. However, fog computing is still in its infancy, and there are still related open problems. In this paper, we focus on the node discovery problem, i.e., how to add new compute nodes to a fog computing system. Moreover, we discuss how addressing this problem can have a positive impact on various aspects of fog computing, such as fault tolerance, resource heterogeneity, proximity awareness, and scalability. Finally, based on the experimental results that we produce by simulating various distributed compute nodes, we show how addressing the node discovery problem can improve the fault tolerance of a fog computing system.Publicationtype: Conference Paper30 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , A framework for optimization, service placement, and runtime operation in the fogFog computing provides a paradigm for executing Internet of Things services. Enabling the coordinated cooperation among computational, storage, and networking resources in the fog can be challenging due to the volatility of resources. For this reason, we design an architecture and implement a representative framework called FogFrame that defines the necessary communication mechanisms for instantiating and maintaining service execution in the fog. To evaluate our approach, we conduct a series of experiments that show how service placement, deployment, and execution is performed by the framework, and how the framework operates at runtime, i.e., adapts to changes in the available resources, balances the workload and recovers from resource failures and overloads.Publicationtype: Conference Paper36 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , Optimized IoT service placement in the fog(2017-12-01); ; ; ; The Internet of Things (IoT) leads to an ever-growing presence of ubiquitous networked computing devices in public, business, and private spaces. These devices do not simply act as sensors, but feature computational, storage, and networking resources. Being located at the edge of the network, these resources can be exploited to execute IoT applications in a distributed manner. This concept is known as fog computing. While the theoretical foundations of fog computing are already established, there is a lack of resource provisioning approaches to enable the exploitation of fog-based computational resources. To resolve this shortcoming, we present a conceptual fog computing framework. Then, we model the service placement problem for IoT applications over fog resources as an optimization problem, which explicitly considers the heterogeneity of applications and resources in terms of Quality of Service attributes. Finally, we propose a genetic algorithm as a problem resolution heuristic and show, through experiments, that the service execution can achieve a reduction of network communication delays when the genetic algorithm is used, and a better utilization of fog resources when the exact optimization method is applied.Publicationtype: Journal Article33 - Some of the metrics are blocked by yourconsent settings
Item type:Publication, Access status: without files , Nomadic applications traveling in the fogThe emergence of the Internet of Things introduces new challenges like network congestion or data privacy. However, it also provides opportunities, such as computational resources close to data sources, which can be pooled to realize Fogs to run software applications on the edge of the network. To foster this new type of resources, we revisit the concept of mobile agents and evolve them to so-called nomadic applications, which allow addressing vital challenges for the Internet of Things. In this paper, we propose a system design to realize nomadic applications and discuss several challenges that need to be addressed in order to apply them to real-world scenarios.Publicationtype: Conference Paper22