The data owner rents storage space located in several data centers around the world and pays a monthly usage-based real rent. Each virtual node is responsible for the data in its key range and should always try to keep data availability above a certain minimum level required by the application while minimizing the associated costs (i.e. for data hosting and maintenance). To this end, a virtual node can be assumed to act as an autonomous agent on behalf of the data owner to achieve these goals. Time is assumed to be split into epochs. A virtual node may replicate or migrate its data to another server, or suicide (i.e. delete its data replica) at each epoch and pay a virtual rent (i.e. an approximation of the possible real rent, de- fined later in this section) to servers where its data are stored. These decisions are made based on the query rate for the data of the vir- tual node, the renting costs and the maintenance of high availability upon failures. There is no global coordination and each virtual node behaves independently. Only one virtual node of the same partition is allowed to suicide at the same epoch by employing Paxos  distributed consensus algorithm among virtual nodes of the same partition. The virtual rent of each server is announced at a board and is updated at the beginning of a new epoch.
Apache spark  is a big data in-memory processing framework that runs on multiple clusters. It provides good reliability and fault tolerance along with in-memory processing features. The different regulated transformations and queries are supported on the datasets, which are essentially parallel and faulttolerant. Spark contains following modules a) core library supports basic Input and output operations along with core processing b) SQL and data frame library supports SQL related operations. C) Streaming library which supports scalable streaming applications d) Mlib library which provides Machine learning algorithm support. e) GraphX library provides supports for graph processing. Streaming supports data insertion from multiple sources like Kafka, Flume, Hadoop Distributed File System, Amazon S3, Kinesis, Twitter and etc.. It also affords an abstraction of DStreams which encloses batches of data produced from the real-time streaming source. The DStream is represented as a sequence of resilient distributed datasets to perform the basic spark operations.
For simulation purposes, our application scenario lets nodes inquire the state of other nodes in the system at random intervals. Assume that node 11 has sent a HOW ARE Y OU message to a failed node 4 in Figure 3.1. On failure detection, it sends a N ODE F AILU RE message to the root (assuming the failed node is not the root and all the nodes have a consistent view). The root recalculates its tree structure by eliminating the failed node from its list of nodes and updates corresponding links to its children in the tree, as depicted in Figure 3.2. The root node initiates the next step of the algorithm by sending a F AILED N ODE message to its children. Each child propagates the message down the tree after recalculating its local view (tree). The flag variable in the node failure algorithm can have 0 or 1 as its value and it indicates node failure and root failure respectively.
Hyper-heuristics must positively influence the selection of heuristics. The optimized heuristics for a given problem should compute high quality solutions. The learning point should refine the algorithms, so that the algorithm solutions subsequently meet the needs of the training set and problems of a certain class can be solved more efficiently. The response mechanism should move towards optimum algorithm solutions in the workspace, as it guides the selection of heuristic. The Algorithm Selection Problem represents in a three-dimensional coordinate system namely the relationship between a problem instance, an algorithm solution and its performance. Comparatively, the two-level model offers a clear separation between the optimization of an algorithm and the optimization process of a specific problem.
Previous works in faulttolerant cellular genetic al- gorithm (FT-cGA) field can be categorized into two groups where each one has a distinct fault model. The first model is, the single event error (SEE) that occurs at registers that store the scores of chromosomes. The next model, is the SEE incurring at fitness score reg- ister. Reyes. et al  designed faulttolerant cellular genetic algorithm using the basic competency of this algorithm. In this reference, fault tolerance character- istic was obtained with the appropriate exploitation of basic parameters and genetic operators in cGAs. The fault model in this method is the occurrence of a single hard error (SHE) at fitness score registers. Moreover, the use of migration operator and controlled selec- tion intensity, are important gadgets in the method. In  an adaptive method was described that is ro- bust to SHEs when incurred at chromosome registers. In this method, decreasing genotype diversity of the chromosome register is caused by the occurrence of SHE errors. In , cellular Genetic algorithm and the distributed one are merged to one structure. SHEs affect the fitness register as the fault model of this reference. In this strategy, when a fault is diagnosed, the migration is done between the cellular and the distributed structure. Meanwhile, the impression of migration policies and adaptive design is very impor-
This paper presents efficient faulttolerant adder/subtractor in terms of gate count, constant input, garbage output and quantum cost. The proposed design can work as single unit that can act as adder as well as subtractor depending upon the requirement.
In this paper, we consider the fault-tolerant control problem for aerial vehicles with redundant actuators. The redundant actuator brings diﬃculty in fault identiﬁcation and isolation. Active fault-tolerant control is adopted in this paper as it can detect actuator fault. The entire proposed fault-tolerant control algorithm contains a baseline controller, the fault detection and isolation scheme, and the controller reconstruction module. A robust parameter identi ﬁ cation method is designed to identify the torque and thrust generated by the actuators. The feasibility of isolating the fault for the redundant actuators is analyzed through mathematical proof. Through the analysis, the practical fault isolation algorithm is also proposed. Two typical aerial vehicles with redundant actuators, an eight-rotor aircraft and a hexa-rotor aircraft, are adopted in numerical simulations to verify the e ﬀ ectiveness of the proposed fault-tolerant control approach.
An important issue in the design of a neural network is the sensitivity of its output to input and weight faults. In this paper, new fault metrics for sensitivity analysis is derived. The experimental derivation of the derived fault metrics is demonstrate that upper bound envelop exist with empirical error of the neural network. Correlation coefficient between MEANWSZ and derived sensitivity analysis for each problem concludes that derived fault metric gives the better results.
Table IV shows the scheduling results of software/hardware hybrid tasks with parameters same to SSHTNB algorithm. As can be seen from Table IV, the average utilization ratio of processor decreases with the fault-tolerant number increase, however the decrease becomes unobvious with the processor number increase. For example, when there are 8 processors in the system, the processor’s utilization ratio decreases by 24.7%, however when there are 64 processors, the ratio only decreases 2.8%. The reason is that if the fault-tolerant number is f, the task set T must be scheduled on m-f processors according theorem 3. When m is few, the task’s load will too large to be scheduled on m-f processors, so the processor utilization ratio is lower.
Dynamic recovery is required when only one copy of computation is running at a time (or in some cases two unchecked copies), and it involves automated self- repair. As in fault masking, the computing system is partitioned into modules backed up by spares as protective redundancy. In the case of dynamic recovery however, special mechanisms are required to detect faults in the modules, switch out a faulty module, switch in a spare, and instigate those software actions (rollback, initialization, retry, restart) necessary to restore and continue the computation. In single computers special hardware is required along with software to do this, while in multicomputer the function is often managed by the other processors. Dynamic recovery is more hardware-efficient than voted systems, and it is therefore the approach of choice in resource-constrained (e.g., low power) systems, and especially in high computing must be maximized. Its advantage is that computational delays occur during fault recovery, fault coverage is often lower, and specialized operating system may be required.
Most often the nodes are fully connected, i.e., every node in layer l is connected to every node in layer l+1. In this paper we assume input vector as the first layer in the neural network. MLP networks can easily perform Boolean logic operations, pattern recognition, classification and nonlinear function approximation . Usually output neurons use linear activation functions rather than nonlinear sigmoid, since this tends to make learning easier. MLP is a supervised neural network that learns through examples and BP is the most common used learning algorithm that is a steepest descent gradient-based algorithm. In this paper we assume that the activation function of each neuron is a
Multi-Protocol Label Switching (MPLS) is a QoS sustain system where packets can be tagged. Routers utilize the tags to ahead packets beside predefined trails. MPLS is frequently utilized with a multi-commodity stream optimizer, which identifies routes supported on flow principles . Every cluster in the routing algorithm has the possible to acquire gateway nodes, which sustain communiqué with contiguous clusters using the operations. Abundant schemes survive for collecting nodes in MANETs. QoS algorithms builds nonoverlapping clusters supported on bandwidth and stoppage factors for every link . The Virtual Grid Construction (VGA)  utilizes position information from the worldwide Positioning scheme to group nodes into a preset rectilinear practical topology to create routing and system management as competent as possible.
based on the safety level of avionics systems. In this mechanism, each software level use separate memory pages, stack, private data and inter-level shared data. Kernel is responsible for controlling the interactions between these levels and schedule tasks based on the safety levels. Memory management unit (MMU) is responsible to separate memory usage of tasks and allocate each task with separate memory space. Whenever each task is being executed, MMU will switch to the memory page of the running task and context switch will happen as fast as possible with isolating content of each task from other tasks. Inter-layer data between tasks can be passed through shared memory and mutual exclusion (mutex) mechanism. Based on the software level, having a backup of the available data might be necessary. In this case, a copy of the variables would be stored and restored in case of the fault detection. Multiple copies of data for catastrophic tasks are necessary. After completion of each operation, all available copies would be compared and the majority value would be chosen as the correct value.
before data communication between Source (S) and Destination (D). If we are unable to get the response then we are sure that the node is totally failed. Then we connect the adjacent nodes of the failed node to tolerate the faults in the network by using a Node Connection algorithm. Then we send the data from Source to Destination. Thirdly, we use the Route Discovery algorithm to decide the minimum cost route to reach the destination by resisting the malicious node attacks in the network. This is done by using DSR algorithm.
The object oriented nature of Java facilitates code reuse and significantly reduces development time. JVM however does not support fault-tolerance. Fault-tolerance is enabled by using systems such as Nomads  which modify the JVM to capture the execution state of the application. This is however inappropriate for heterogeneous systems where different machines may have different JVMs. Ref.  describes an approach to make check-pointing JVM independent by modifying the program’s bytecode rather than modifying the JVM. 6. Conclusion and Future Work