Kamilla Klonowska

Optimal recovery schemes in fault tolerant distributed computing

Abstract.Clusters and distributed systems offer fault tolerance and high performance through load sharing. When all n computers are up and running, we would like the load to be evenly distributed among the computers. When one or more computers break down, the load on these computers must be redistributed to other computers in the system. The redistribution is determined by the recovery scheme. The recovery scheme is governed by a sequence of integers modulo n. Each sequence guarantees minimal load on the computer that has maximal load even when the most unfavorable combinations of computers go down. We calculate the best possible such recovery schemes for any number of crashed computers by an exhaustive search, where brute force testing is avoided by a mathematical reformulation of the problem and a branch-and-bound algorithm. The search nevertheless has a high complexity. Optimal sequences, and thus a corresponding optimal bound, are presented for a maximum of twenty one computers in the distributed system or cluster.

Using Golomb rulers for optimal recovery schemes in fault tolerant distributed computing

Clusters and distributed systems offer fault tolerance and high performance through load sharing. When all computers are up and running, we would like the load to be evenly distributed among the computers. When one or more computers break down the load on these computers must be redistributed to other computers in the cluster. The redistribution is determined by the recovery scheme. The recovery scheme should keep the load as evenly distributed as possible even when the most unfavorable combinations of computers break down, i.e. we want to optimize the worst-case behavior. In this paper we define recovery schemes, which are optimal for a number of important cases. We also show that the problem of finding optimal recovery schemes corresponds to the mathematical problem called Golomb rulers. These provide optimal recovery schemes for up to 373 computers in the cluster.

Recovery schemes for high availability and high performance distributed real-time computing

Clusters and distributed systems offer fault tolerance and high performance through load sharing, and are thus attractive in real-time applications. When all computers are up and running, we would like the load to be evenly distributed among the computers. When one or more computers-fail the must be redistributed. The redistribution is determined by the recovery scheme. The recovery scheme should keep the load as evenly distributed as possible even when the most unfavorable combinations of computers break down, i.e. we want to optimize the worst-case behavior. In this paper we define recovery schemes, which are optimal for a number of important cases. We also show that the problem of finding optimal recovery schemes corresponds to the mathematical problem of finding sequences of integers with minimal sum and for which all sums of subsequences are unique.

Using modulo rulers for optimal recovery schemes in distributed computing

Clusters and distributed systems offer fault tolerance and high performance through load sharing. When all computers are up and running, we would like the load to be evenly distributed among the computers. When one or more computers break down the load on these computers must be redistributed to other computers in the cluster. The redistribution is determined by the recovery scheme. The recovery scheme should keep the load as evenly distributed as possible even when the most unfavorable combinations of computers break down, i.e. we want to optimize the worst-case behavior. We define recovery schemes, which are optimal for a larger number of computers down than in previous results. We also show that the problem of finding optimal recovery schemes for a cluster with n computers corresponds to the mathematical problem of finding the longest sequence of positive integers for which the sum of the sequence and the sums of all subsequences modulo n are unique.

Extended Golomb rulers as the new recovery schemes in distributed dependable computing

Clusters and distributed systems offer fault tolerance and high performance through load sharing. When all computers are up and running, we would like the load to be evenly distributed among the computers. When one or more computers break down the load on these computers must be redistributed to other computers in the cluster. The redistribution is determined by the recovery scheme. The recovery scheme should keep the load as evenly distributed as possible even when the most unfavorable combinations of computers breakdown, i.e. we want to optimize the worst-case behavior. We have previously defined recovery schemes that are optimal for some limited cases. In this paper we find a new recovery schemes that are based on so called Golomb rulers. They are optimal for a much larger number of cases than the previous results.

Advances in Computer Science - ASIAN 2004. Higher-Level Decision Making

Keynote Papers.- Counting by Coin Tossings.- On the Role Definitions in and Beyond Cryptography.- Meme Media for the Knowledge Federation Over the Web and Pervasive Computing Environments.- Contributed Papers.- Probabilistic Space Partitioning in Constraint Logic Programming.- Chi-Square Matrix: An Approach for Building-Block Identification.- Design Exploration Framework Under Impreciseness Based on Register-Constrained Inclusion Scheduling.- Hiord: A Type-Free Higher-Order Logic Programming Language with Predicate Abstraction.- Assessment Aggregation in the Evidential Reasoning Approach to MADM Under Uncertainty: Orthogonal Versus Weighted Sum.- Learnability of Simply-Moded Logic Programs from Entailment.- A Temporalised Belief Logic for Specifying the Dynamics of Trust for Multi-agent Systems.- Using Optimal Golomb Rulers for Minimizing Collisions in Closed Hashing.- Identity-Based Authenticated Broadcast Encryption and Distributed Authenticated Encryption.- Deniable Partial Proxy Signatures.- Formal Concept Mining: A Statistic-Based Approach for Pertinent Concept Lattice Construction.- A Robust Approach to Content-Based Musical Genre Classification and Retrieval Using Multi-feature Clustering.- Registration of 3D Range Images Using Particle Swarm Optimization.- Zero-Clairvoyant Scheduling with Inter-period Constraints.- A Novel Texture Synthesis Based Algorithm for Object Removal in Photographs.- Highly Efficient and Effective Techniques for Thai Syllable Speech Recognition.- Robot Visual Servoing Based on Total Jacobian.- Invited Papers.- Online Stochastic and Robust Optimization.- Optimal Constraint Decomposition for Distributed Databases.- Adaptive Random Testing.- Minimal Unsatisfiable Sets: Classification and Bounds.- LPOD Answer Sets and Nash Equilibria.- Graph Theoretic Models for Reasoning About Time.- Rule-Based Programming and Proving: The ELAN Experience Outcomes.- Towards Flexible Graphical Communication Using Adaptive Diagrams.- A Framework for Compiler Driven Design Space Exploration for Embedded System Customization.- Spectral-Based Document Retrieval.- Metadata Inference for Document Retrieval in a Distributed Repository.- A Simple Theory of Expressions, Judgments and Derivations.- Reactive Framework for Resource Aware Distributed Computing.- The Feature Selection and Intrusion Detection Problems.- On the BDD of a Random Boolean Function.- Concurrent Constraint-Based Memory Machines: A Framework for Java Memory Models (Summary).

Evaluating Heuristic Scheduling Algorithms for High Performance Parallel Processing

Most cluster systems used in high performance computing do not allow process relocation at run-time. Finding an allocation that results in minimal completion time is NP-hard and (non-optimal) heuristic algorithms have to be used. One major drawback with heuristics is that we do not know if the result is close to optimal or not. Here, we present a method for finding an upper bound on the minimal completion time for a given program. The bound helps the user to determine when it is worth-while to continue the heuristic search for better allocations. Based on some parameters derived from the program, as well as some parameters describing the hardware platform, the method produces the minimal completion time bound. A practical demonstration of the method is presented using a tool that produces the bound.

Using optimal golomb rulers for minimizing collisions in closed hashing

We give conditions for hash table probing which minimize the expected number of collisions. A probing algorithm is determined by a sequence of numbers denoting jumps for an item during multiple collisions. In linear probing, this sequence consists of only ones – for each collision we jump to the next location. To minimize the collisions, it turns out that one should use the Golomb ruler conditions: consecutive partial sums of the jump sequence should be distinct. The commonly used quadratic probing scheme fulfils the Golomb condition for some cases. We define a new probing scheme – Golomb probing – that fulfills the Golomb conditions for a much larger set of cases. Simulations show that Golomb probing is always better than quadratic and linear and in some cases the collisions can be reduced with 25% compared to quadratic and with more than 50% compared to linear.

Bounding the minimal completion time in high-performance parallel processing

Many parallel systems used in high-performance computing do not allow process relocation at run-time. It is thus important to find a good allocation of processes to processors. As the problem of finding an allocation that results in minimal completion time is NP-hard, one has to resort to heuristic algorithms for finding good allocations. One major drawback with heuristic algorithms is that we do not know whether the result is close to optimal or it is worthwhile to continue the heuristic search for better allocations. In this paper, we present a method for finding an upper bound on the minimal completion time for a given program. If the completion time using the current allocation is above this bound, we know that it is worthwhile to continue the search for better allocations. The bound, which is optimally tight using the available information, is based on some parameters derived from the program and describing the hardware platform. A practical demonstration of the method is presented using a tool that produces the bound for multithreaded C-programs executing in a parallel Sun/Solaris environment.

Comparing the Optimal Performance of Parallel Architectures

Consider a parallel program with n processes and a synchronization granularity z. Consider also two parallel architectures: an SMP with q processors and run-time reallocation of processes to processors, and a distributed system (or cluster) with k processors and no run-time reallocation. There is an inter-processor communication delay of t time units for the system with no run-time reallocation. In this paper we define a function H(n,k,q,t,z) such that the minimum completion time for all programs with n processes and a granularity z is at most H(n,k,q,t,z) times longer using the system with no reallocation and k processors compared to using the system with q processors and run-time reallocation. We assume optimal allocation and scheduling of processes to processors. The function H(n,k,q,t,z)is optimal in the sense that there is at least one program, with n processes and a granularity z, such that the ratio is exactly H(n,k,q,t,z). We also validate our results using measurements on distributed and multiprocessor Sun/Solaris environments. The function H(n,k,q,t,z) provides important insights regarding the performance implications of the fundamental design decision of whether to allow run-time reallocation of processes or not. These insights can be used when doing the proper cost/benefit trade-offs when designing parallel execution platforms.