scholarly journals Generic Controller Adaptive Load Balancing (GCALB) for SDN Networks

2019 ◽  
Vol 2019 ◽  
pp. 1-9 ◽  
Author(s):  
Wael Hosny Fouad Aly
Keyword(s):  
Fault Tolerance ◽  
Load Balancing ◽  
Response Time ◽  
Fault Tolerant ◽  
High Reliability ◽  
Tolerance Mechanisms ◽  
New Era ◽  
Proposed Model ◽  
New Strategies

Fault tolerance is an important aspect of network resilience. Fault-tolerance mechanisms are required to ensure high availability and high reliability in different environments. The beginning of software-defined networking (SDN) has both presented new challenges and opened a new era to develop new strategies, standards, and architectures to support fault tolerance. In this paper, a study of fault tolerance is performed for two architectures: (1) a single master with multiple slave controllers and (2) multiple slave controllers. The proposed model is called a Generic Controller Adaptive Load Balancing (GCALB) model for SDNs. GCALB adapts the load among slave controllers based on a GCALB algorithm. Mininet simulation tool is utilized for the experimentation phase. Controllers are implemented using floodlights. Experiment results were conducted using GCALB when master controller is taking the responsibility of distributing switches among four and five slave controllers as a case study. Throughput and response time metrics are used to measure performance. GCALB is compared with two reference algorithms: (1) HyperFlow (Kreutz et al., 2012), and (2) Enhanced Controller Fault Tolerant (ECFT) (Aly and Al-anazi, 2018). Results are promising as the performance of GCALB increased by 15% and 12% when compared to HyperFlow and by 13% and 10% when compared to ECFT in terms of throughput and response time.

A Design for Fault-Tolerant Communication Middleware Based on Time-Triggered

2014 ◽  
Vol 548-549 ◽  
pp. 1326-1329
Author(s):  
Juan Jin ◽  
Qing Fan Gu
Keyword(s):  
Fault Tolerance ◽  
Real Time ◽  
Fault Location ◽  
Fault Tolerant ◽  
Application Software ◽  
Tolerance Mechanisms ◽  
The Real ◽  
Communication Middleware ◽  
Fault Mechanism ◽  
Health Diagnosis

Against to the unsustainable problems of health diagnosis, fault location and fault tolerance mechanisms that existing in the current avionics applications, we proposed a fault-tolerant communication middleware which is based on time-triggered in this paper. This middleware is designed to provide a support platform for applications of the real-time based on communication middleware. From the communication middleware level and also combined with time-triggered mechanism and fault-tolerant strategy, it diagnoses the general faults first, and then routes them to the appropriate fault mechanism to process it. So the middleware completely separates fault-tolerant process from the application software functions.

scholarly journals System Control In Fault And Normal Conditions Case Study - Quanser SRV-02

2015 ◽  
Vol 67 (1) ◽  
pp. 133-138
Author(s):  
Ionut Cristian Resceanu ◽  
Cristina Floriana Resceanu
Keyword(s):  
Fault Tolerance ◽  
Theoretical Analysis ◽  
Control Method ◽  
Fault Tolerant ◽  
Fault Tolerant Control ◽  
Control Law ◽  
System Control ◽  
Sensor Fault ◽  
Simulation Results

Abstract A fault tolerant control method is proposed for Quanser SRV-02 System in order to maintain the required performance in the presence of sensor failures. The proposed approach integrates control law and a sensor fault tolerance schema. Theoretical analysis and simulation results have confirmed the effectiveness of the proposed method.

scholarly journals Increasing fault tolerance in service-level agreement constrained context-aware data networks

2020 ◽  
Vol 13 (2) ◽  
pp. 16-21
Author(s):  
Ints Meijers
Keyword(s):  
Fault Tolerance ◽  
Fault Tolerant ◽  
Service Level Agreement ◽  
Service Level ◽  
Data Networks ◽  
Multiple Constraints ◽  
Context Aware ◽  
Network Availability ◽  
Proposed Model ◽  
Best Fitting

Abstract Attribute study and analysis of fault tolerant data networks. This work is aimed at introducing SLA constrain into fault tolerance and thus increasing overall network availability. Proposed model will evaluate given constraints and select best path that fits requirements. Fault tolerance is increased by adding multiple constraints and thus reducing available paths to best fitting ones.

scholarly journals A Multiconstrained Grid Scheduling Algorithm with Load Balancing and Fault Tolerance

2015 ◽  
Vol 2015 ◽  
pp. 1-10 ◽  
Author(s):  
P. Keerthika ◽  
P. Suresh
Keyword(s):  
Resource Allocation ◽  
Fault Tolerance ◽  
Load Balancing ◽  
User Satisfaction ◽  
Fault Tolerant ◽  
Scheduling Algorithm ◽  
Grid Environment ◽  
Resource Allocation Algorithm ◽  
Processing Cost ◽  
Comparison Results

Grid environment consists of millions of dynamic and heterogeneous resources. A grid environment which deals with computing resources is computational grid and is meant for applications that involve larger computations. A scheduling algorithm is said to be efficient if and only if it performs better resource allocation even in case of resource failure. Allocation of resources is a tedious issue since it has to consider several requirements such as system load, processing cost and time, user’s deadline, and resource failure. This work attempts to design a resource allocation algorithm which is budget constrained and also targets load balancing, fault tolerance, and user satisfaction by considering the above requirements. The proposed Multiconstrained Load Balancing Fault Tolerant algorithm (MLFT) reduces the schedule makespan, schedule cost, and task failure rate and improves resource utilization. The proposed MLFT algorithm is evaluated using Gridsim toolkit and the results are compared with the recent algorithms which separately concentrate on all these factors. The comparison results ensure that the proposed algorithm works better than its counterparts.

Fault Tolerance Techniques for Distributed, Parallel Applications

2016 ◽  
pp. 221-252
Author(s):  
Camille Coti
Keyword(s):  
Fault Tolerance ◽  
High Performance Computing ◽  
High Performance ◽  
Fault Tolerant ◽  
Distributed Applications ◽  
Parallel Applications ◽  
Rollback Recovery ◽  
Tolerance Mechanisms ◽  
Performance Computing

This chapter gives an overview of techniques used to tolerate failures in high-performance distributed applications. We describe basic replication techniques, automatic rollback recovery and application-based fault tolerance. We present the challenges raised specifically by distributed, high performance computing and the performance overhead the fault tolerance mechanisms are likely to cost. Last, we give an example of a fault-tolerant algorithm that exploits specific properties of a recent algorithm.

scholarly journals The Application of Fractal Transform and Entropy for Improving Fault Tolerance and Load Balancing in Grid Computing Environments

Entropy ◽  
2020 ◽  
Vol 22 (12) ◽  
pp. 1410
Author(s):  
Murad B. Khorsheed ◽  
Qasim M. Zainel ◽  
Oday A. Hassen ◽  
Saad M. Darwish
Keyword(s):  
Fault Tolerance ◽  
Load Balancing ◽  
Grid Computing ◽  
Computing Time ◽  
Index Structure ◽  
Computational Grids ◽  
Optimum Number ◽  
Logical Network ◽  
Proposed Model ◽  
Cloud Of Points

This paper applies the entropy-based fractal indexing scheme that enables the grid environment for fast indexing and querying. It addresses the issue of fault tolerance and load balancing-based fractal management to make computational grids more effective and reliable. A fractal dimension of a cloud of points gives an estimate of the intrinsic dimensionality of the data in that space. The main drawback of this technique is the long computing time. The main contribution of the suggested work is to investigate the effect of fractal transform by adding R-tree index structure-based entropy to existing grid computing models to obtain a balanced infrastructure with minimal fault. In this regard, the presented work is going to extend the commonly scheduling algorithms that are built based on the physical grid structure to a reduced logical network. The objective of this logical network is to reduce the searching in the grid paths according to arrival time rate and path’s bandwidth with respect to load balance and fault tolerance, respectively. Furthermore, an optimization searching technique is utilized to enhance the grid performance by investigating the optimum number of nodes extracted from the logical grid. The experimental results indicated that the proposed model has better execution time, throughput, makespan, latency, load balancing, and success rate.

A CPN Based Method for Aspect-Oriented Modeling and Analysis of Fault Tolerance

2012 ◽  
Vol 457-458 ◽  
pp. 891-898
Author(s):  
Xiao Xing Sun ◽  
Hui Qun Yu ◽  
Hong Hao Liang
Keyword(s):  
Fault Tolerance ◽  
Fault Tolerant ◽  
Aspect Oriented Programming ◽  
Modeling And Analysis ◽  
Cpn Tools ◽  
Tolerance Modeling ◽  
Software Fault Tolerance ◽  
Implementation Level ◽  
Aspect Oriented Modeling

Software fault tolerance makes system complicated by means of diverse fault-tolerant mechanisms. Aspect-oriented programming has been confirmed as a well suited candidate to ease the problem. However, most of the existing works only focus on implementation level. This paper proposes an AOFTM model for aspect-oriented fault tolerance modeling with Coloured Petri nets at design level. Moreover, the weaving mechanism formally defined conducts the way to derive a woven net from AOFTM. A case study presents how AOFTM works, and its properties are analyzed using the CPN Tools.

scholarly journals QoS Aware and Fault Tolerance Based Software-Defined Vehicular Networks Using Cloud-Fog Computing

Sensors ◽  
2022 ◽  
Vol 22 (1) ◽  
pp. 401
Author(s):  
Sidra Abid Syed ◽  
Munaf Rashid ◽  
Samreen Hussain ◽  
Fahad Azim ◽  
Hira Zahid ◽  
...  
Keyword(s):  
Fault Tolerance ◽  
Response Time ◽  
Communication Systems ◽  
Vehicular Networks ◽  
Heuristic Algorithms ◽  
Fog Computing ◽  
Research Work ◽  
Tolerance Mechanism ◽  
Proposed Model ◽  
Sdn Controller

Software-defined network (SDN) and vehicular ad-hoc network (VANET) combined provided a software-defined vehicular network (SDVN). To increase the quality of service (QoS) of vehicle communication and to make the overall process efficient, researchers are working on VANET communication systems. Current research work has made many strides, but due to the following limitations, it needs further investigation and research: Cloud computing is used for messages/tasks execution instead of fog computing, which increases response time. Furthermore, a fault tolerance mechanism is used to reduce the tasks/messages failure ratio. We proposed QoS aware and fault tolerance-based software-defined V vehicular networks using Cloud-fog computing (QAFT-SDVN) to address the above issues. We provided heuristic algorithms to solve the above limitations. The proposed model gets vehicle messages through SDN nodes which are placed on fog nodes. SDN controllers receive messages from nearby SDN units and prioritize the messages in two different ways. One is the message nature way, while the other one is deadline and size way of messages prioritization. SDN controller categorized in safety and non-safety messages and forward to the destination. After sending messages to their destination, we check their acknowledgment; if the destination receives the messages, then no action is taken; otherwise, we use a fault tolerance mechanism. We send the messages again. The proposed model is implemented in CloudSIm and iFogSim, and compared with the latest models. The results show that our proposed model decreased response time by 50% of the safety and non-safety messages by using fog nodes for the SDN controller. Furthermore, we reduced the execution time of the safety and non-safety messages by up to 4%. Similarly, compared with the latest model, we reduced the task failure ratio by 20%, 15%, 23.3%, and 22.5%.

scholarly journals Técnicas de Tolerância a Falhas em uma Plataforma para Prototipagem Rápida Usando Microcontroladores

2019 ◽  
Author(s):  
Kleber Kruger ◽  
Fabio Iaione
Keyword(s):  
Fault Tolerance ◽  
Power Consumption ◽  
Rapid Prototyping ◽  
System Performance ◽  
Processing Time ◽  
Fault Tolerant ◽  
Weather Station ◽  
Fault Tolerant System ◽  
Sram Memory

This paper describes the implementation of fault tolerance techniques (based on data and processing redundancy) in programming of a rapid prototyping platform using microcontrollers. To evaluate performance of these techniques was used a fault injector software and a weather station system as a case study. Experiments simulated faults in sensor readings and faults in SRAM memory regions of the weather station. Finally, the fault-tolerant system performance is presented in comparison with non-fault-tolerant system, considering incidence of failures, processing time, memory and power consumption.

Sign in / Sign up

Export Citation Format

Share Document