Yaacov Yesha

Mutation operators for specifications

Testing has a vital support role in the software engineering process, but developing tests often takes significant resources. A formal specification is a repository of knowledge about a system, and a recent method uses such specifications to automatically generate complete test suites via mutation analysis. We define an extensive set of mutation operators for use with this method. We report the results of our theoretical and experimental investigation of the relationships between the classes of faults detected by the various operators. Finally, we recommend sets of mutation operators which yield good test coverage at a reduced cost compared to using all proposed operators.

Quantizer design for distributed estimation with communication constraints and unknown observation statistics

We consider the problem of quantizer design in a distributed estimation system with communication constraints in the case where only a training sequence is available. Our approach is based on a generalization of regression trees. The look-ahead method that we also propose improves significantly the performance. The final system performs similarly to the one that assumes known statistics.

Parallel recognition and decomposition of two terminal series parallel graphs

Abstract In this paper, we develop a parallel recognition and decomposition algorithm for two-terminal series parallel (TTSP) graphs. Given a directed acyclic graph G in edge list form, the algorithm determines whether G is a TTSP graph. If G is a TTSP graph, the algorithm constructs a decomposition tree for G . Some interesting properties of the TTSp graphs are derived in order to facilitate fast parallel processing. The algorithm runs in O (log 2 n + log m ) time with O ( n + m ) processors on an exclusive read exclusive write PRAM where n ( m ) is the number of vertices (edges) in G . This algorithm is within a polylogrithmic factor of optimal.

Comparison of fault classes in specification-based testing

Abstract Our results extending Kuhns fault class hierarchy provide a justification for the focus of fault-based testing strategies on detecting particular faults and ignoring others. We develop a novel analytical technique which allows us to elegantly prove that the hierarchy applies to arbitrary expressions, not just those in disjunctive normal form. We also use the technique to extend the hierarchy to a wider range of fault classes. To demonstrate broad applicability, we compare faults in practical situations and analyze previous results. In particular, using our technique, we show that the basic meaningful impact strategy of Weyuker et al. tests for stuck-at faults, not just variable negation faults.

Binary tree algebraic computation and parallel algorithms for simple graphs

Abstract In this paper we define the binary tree algebraic computation (BTAC) problem and develop an efficient parallel algorithm for solving this problem. A variety of graph problems (minimum covering set, minimum r-dominating set, maximum matching set, etc.) for trees and two terminal series parallel (TTSP) graphs can be converted to instances of the BTAC problem. Thus efficient parallel algorithms for these problems are obtained systematically by using the BTAC algorithm. The parallel computation model is an exclusive read exclusive write PRAM. The algorithms for tree problems run in O (log n ) time with O ( n ) processors. The algorithms for TTSP graph problems run in O (log m ) time with O ( m ) processors where n ( m ) is the number of vertices (edges) in the input graph. These algorithms are within an O (log n ) factor of optimal.

Mutation of model checker specifications for test generation and evaluation

Mutation analysis on model checking specifications is a recent development. This approach mutates a specification, then applies a model checker to compare the mutants with the original specification to automatically generate tests or evaluate coverage. The properties of specification mutation operators have not been explored in depth. We report our work on theoretical and empirical comparison of these operators. Our future plans include studying how the form of a specification influences the results, finding relations between different operators, and validating the method against independent metrics.

Parallel recognition of the consecutive ones property with applications

Given a (0, 1)-matrix, the problem of recognizing the consecutive 1s property for rows is to decide whether it is possible to permute the columns such that the resulting matrix has the consecutive 1s in each of its rows. In this paper, we give the first NC algorithm for this problem. The algorithm runs in O(log n + log2 m) time using O(m2n + m3) processors on Common CRCW PRAM, where m × n is the size of the matrix. The algorithm can be extended to detect the circular 1s property within the same resource bounds. We can also make use of the algorithm to recognize convex bipartite graphs in O(log2 n) time using O(n3) processors, where n is the number of vertices in a graph. We further show that the maximum matching problem for arbitrary convex bipartite graphs can be solved within the same complexity bounds, combining the work by Dekel and Sahni, who gave an efficient parallel algorithm for computing maximum matchings in convex bipartite graphs with the condition that the neighbors of each vertex in one vertex set of a bipartite graph occur consecutively in the other vertex set. This broadens the class of graphs for which the maximum matching problem is known to be in NC.

Efficient parallel algorithms for bipartite permutation graphs

In this paper, we further study the properties of bipartite permutation graphs. We give first efficient parallel algorithms for several problems on bipartite permutation graphs. These problems include transforming a bipartite graph into a strongly ordered one if it is also a permutation graph; testing isomorphism; finding a Hamiltonian path/cycle; solving a variant of the crossing number problem; and others. All these problems can be solved in O(log2n) time with O(n3) processors on a Common CRCW PRAM. We also show that the minimum fill-in problem for bipartite permutation graphs can be solved efficiently by a randomized parallel algorithm.

The generalized Sprague-Grundy function and its invariance under certain mappings

Abstract The equivalence of three previously given definitions of the generalized Sprague-Grundy function G is established. A polynomial algorithm for the computation of G is given, and an optimal strategy for the sum of a wide class of two-player games which may contain cycles or loops is formulated, which is one of the main applications of G. Finally, the invariance of G under a mapping of digraphs which may contain cycles or loops is established.

Leveraging Cloud Computing in Geodatabase Management

In this work, we leverage Cloud computing technologies in scaling out data management in geographical databases. In particular, we tackle the issue of data indexing in parallel. First, spatial data is partitioned and indexed in a Hadoop MapReduce cluster. Two main partitioning strategies are evaluated: a) A linear-complexity method based on Zorder values, and b) An iterative algorithm based on X-means clustering. The advantages and drawbacks of each method are weighted in with relation to query performance. Second, interactive queries are processed from a local site using the index data structures built in the Cloud. We perform an experimental study on a real dataset of 110 million spatial objects representing property parcels in the United States. Our results support Cloud computing as an effective technology to cope up with huge datasets and, in particular, MapReduce parallel programming model in easing parallel processing implementations.