11054622
Classification using Efficient LU Decomposition in Sensornets
We consider the popular application of detection, classification and tracking and their feasibility in resource constrained sensornets. We concentrate on the classification aspect, by decomposing the complex, computationally intensive signal processing Maximum-APosterior (MAP) classifier into simpler computationally and communicationally load balanced procedures, using a clustering approach. LU decomposition is an efficient approach for computing the inverse of covariance matrices required in the MAP classifier. We thus explore feasibility of LU decomposition in sensornets. We present power-aware and load balanced techniques for LU decomposition of the covariance matrices in sensornets alongwith their analytical and power consumption analyses.
41859107
Preconditioned Conjugate Gradient Solver for Large Sparse Systems on MPI
14459246
On optimal embeddings into incomplete hypercubes
The authors show the embeddings of various types of n-node incomplete binary trees into n-node or (n+1)-node composite hypercubes with dilation of at most 2. They also present lower bound proofs showing optimality of the dilation. They characterize the class of incomplete binary trees which are subgraphs of composite hypercubes. They present dilation 1 embedding of a two-dimensional n-node mesh, where one dimension is a power of two, into its optimal n-node composite hypercube. When neither dimension is a power of two, it is shown that a dilation 1 embedding is not possible; thereby characterizing the class of two-dimensional meshes that can be embedded into composite hypercubes with dilation 1. All two-dimensional meshes are shown to be embeddable with dilation 1 if expansion greater than 1 but less than 2 is allowed. The authors also consider two types of incomplete meshes and their embeddings into their optimal composite hypercubes.<<ETX>>
10426404
Load balanced tree embeddings
Abstract When an n -processor architecture T is embedded into an m -processor architecture H with n > m and every processor of H is assigned at least ⌞n/m⌟ and at most [ n / m ] processors of T , the embedding has a balanced processor load. We present efficient embeddings with a balanced load for the case when both architectures are complete binary trees. We show that T can be embedded into H with a dilation of 1 and congestion of at most min{[ n / m ], 2 log n }. We also consider embeddings that achieve a balanced l/i load; i.e. every processor of H simulates at most [( n + 1)/2 m ] leaves and at most [( n − 1)/2 m ] interior processors of T . We present an embedding that achieves a balanced l/i load, a dilation of 2[log log m ] + 1 and a congestion of O(log n ). We show that every embedding strategy achieving a balanced l/i load must have a dilation of at least 3. We also consider the embedding problem when every edge of T has a weight associated with it.
35215015
Coarse Grain Preconditioned Conjugate Gradient Solver for Large Sparse Systems
We explore a coarse grain parallel algorithm for the solution of large sparse linear systems with symmetric positive definite matrix, based on a preconditioned conjugate gradient method.
17006088
An Efficient MAP Classifier for Sensornets
The classification phase is computationally intensive and frequently recurs in tracking applications in sensor networks. Most related work uses traditional signal processing classifiers, such as Maximum A Posterior (MAP) classifier. Naive formulations of MAP are not feasible for resource constraint sensornet nodes. In this paper, we study computationally efficient methods for classification. We propose to use one-sided Jacobi iterations for eigen value decomposition of the covariance matrices, the inverse of which are needed in MAP classifier. We show that this technique greatly simplifies the execution of MAP classifier and makes it a feasible and efficient choice for sensornet applications.
96295
Efficient algorithms for pattern matching on directed acyclic graphs
Recently graph data models have become increasingly popular in many scientific fields. Efficient query processing over such data is critical. Existing works often rely on index structures that store pre-computed transitive relations to achieve efficient graph matching. In this paper, we present a family of stack-based algorithms to handle path and twig pattern queries for directed acyclic graphs (DAGs) in particular. With the worst-case space cost linearly bounded by the number of edges in the graph, our algorithms achieve a quadratic runtime complexity in the average size of the query variable bindings. This is optimal among the navigation-based graph matching algorithms.
38885821
Embeddings of k-Connected Graphs of Pathwidth k
We present O(n3) embedding algorithms (generalizing subgraph isomorphism) for classes of graphs of bounded pathwidth, where n is the number of vertices in the graph. These include the first polynomialtime algorithm for minor containment and the first O(nc) algorithm (c a constant independent of k) for topological embedding of graphs from subclasses of partial k-trees. Of independent interest are structural properties of k-connected graphs of bounded pathwidth on which our algorithms are based. We also describe special cases which reduce to various generalizations of string matching, permitting more efficient solutions.
17407466
Point-Based Approaches to Qualitative Temporal Reasoning
We are interested in the problem of qualitative, point-based temporal reasoning. That is, given a set of assertions concerning the relative positions of points in time, we are interested in compiling the assertions into a representation that supports efficient reasoning, determining consistency, computing the strongest entailed relation between any two points and updating the set of assertions. We begin by considering a general set of operations and their corresponding algorithms, applicable to general point-based temporal domains. We also consider special-purpose reasoners, which may be expected to perform well in an application domain with a restricted structure. Lastly we consider reasoners which incorporate restricted structures into a more general reasoning framework. Finally, we present instances of each such approach and give a comparison of their performance on random data sets.
8374849
Quorum placement in networks to minimize access delays
A quorum system is a family of sets (themselves called quorums), each pair of which intersect. In many distributed algorithms, the basic unit accessed by a client is a quorum of nodes. Such algorithms are used for applications such as mutual exclusion, data replication, and dissemination of information. However, accessing spread-out quorums causes access delays that we would like to minimize. Furthermore, every member of the quorum incurs processing load to handle quorum accesses by clients.In this paper we study the problem of placing quorums in a physical network so as to minimize the delay that clients incur by accessing quorums, and while respecting each physical node's capacity (in terms of the load of client requests it can handle). We provide approximation algorithms for this problem for two natural measures of delay (the max-delay and total-delay). All our algorithms ensure that each node's load is within a constant factor of its capacity, and minimize delay to within a constant factor of the optimal delay for all capacity-respecting solutions. We also provide better approximations for several well-known quorum systems.
11038357
Reasoning About Threads Communicating via Locks
We propose a new technique for the static analysis of concurrent programs comprised of multiple threads. In general, the problem is known to be undecidable even for programs with only two threads but where the threads communicate using CCS-style pairwise rendezvous [11]. However, in practice, a large fraction of concurrent programs can either be directly modeled as threads communicating solely using locks or can be reduced to such systems either by applying standard abstract interpretation techniques or by exploiting separation of control from data. For such a framework, we show that for the commonly occurring case of threads with nested access to locks, the problem is efficiently decidable. Our technique involves reducing the analysis of a concurrent program with multiple threads to individually analyzing augmented versions of the given threads. This not only yields decidability but also avoids construction of the state space of the concurrent program at hand and thus bypasses the state explosion problem making our technique scalable. We go on to show that for programs with threads that have non-nested access to locks, the static analysis problem for programs with even two threads becomes undecidable even for reachability, thus sharpening the result of [11]. As a case study, we consider the Daisy file system [1] which is a benchmark for analyzing the efficacy of different methodologies for debugging concurrent programs and provide results for the detection of several bugs.