Himanshu Chauhan

FOLKSOMAPS - towards community driven intelligent maps for developing regions

Many services taken for granted in the developed world are often missing from the developing countries. One typical example is that of map systems that form the basis of several location driven services. Its heavy reliance on content, provides a huge barrier towards building such systems. Further, in developing countries like India, the infrastructure typically has a history of unplanned development, leading to unorganized addresses and absence of standard naming conventions for roads. Detailed map systems such as online maps have only recently started becoming available but for major cities. Remote towns and villages remain out of reach till date. In this paper, we investigate a community-driven approach for creating maps in developing regions - following Web 2.0 principles, but not entirely relying on the existing Web. Our system, dubbed FOLKSOMAPS is an intelligent, community constructed map system, particularly architected with developing regions in mind. We present the design of FOLKSOMAPS, followed by an implementation of our proof-of-concept system. We present user studies aimed at understanding the uptake, usability and utility of FOLKSOMAPS. The results indicate a strong need for such a community-generated mapping ecosystem.

A Distributed Abstraction Algorithm for Online Predicate Detection

Analyzing a distributed computation is a hard problem in general due to the combinatorial explosion in the size of the state-space with the number of processes in the system. By abstracting the computation, unnecessary state explorations can be avoided. Computation slicing is an approach for abstracting distributed computations with respect to a given predicate. We focus on regular predicates, a family of predicates that covers many commonly used predicates for runtime verification. The existing algorithms for computation slicing are centralized - a single process is responsible for computing the slice in either offline or online manner. In this paper, we present first distributed online algorithm for computing the slice of a distributed computation with respect to a regular predicate. Our algorithm distributes the work and storage requirements across the system, thus reducing the space and computation complexity per process.

Efficient abstraction algorithms for predicate detection

Abstract Analyzing a distributed computation is a hard problem in general due to the combinatorial explosion in the size of the state-space with the number of processes in the system. By abstracting the computation, unnecessary state explorations can be avoided. Computation slicing is an approach for abstracting distributed computations with respect to a given predicate. To detect a predicate in a timely manner during run-time verification, it is important to be able to compute the slice in an incremental manner as and when a new event is generated in the system. In this work, we present several online abstraction algorithms for computing the slice of a distributed computation with respect to regular predicates and its temporal extensions. The family of regular predicates is fairly rich and covers many commonly used predicates for run-time verification. We first present several online algorithms for computing the slice with respect to certain temporal logical regular predicates all of which are centralized. We then present a distributed algorithm for computing the slice with respect to a regular state based predicate; it distributes the work and storage requirements across the system, thus reducing the space and computation complexity per process. We also extend the slicing technique to non-regular predicates by presenting algorithms for computing the slice for two temporal logic operators when the predicate used in the operator is not regular.

Democratic Elections in Faulty Distributed Systems

In this paper, we show that for elections in distributed systems the conversion from non-binary choices to binary choices does not always provide optimal results when the preferences of nodes are not identical. With this observation, we study the problem of conducting democratic elections in distributed systems in the form of social choice and social welfare functions with three or more candidates. We present some impossibility and possibility results for distributed democratic elections in presence of Byzantine behavior. We also discuss some existing election schemes, and present a new approach that attempts to mitigate the effects of Byzantine votes. We analyze the performance of these schemes through simulations to compare their efficacy in producing the most desirable social welfare rankings.

Fast Detection of Stable and Count Predicates in Parallel Computations

Enumerating all consistent states of a parallel computation that satisfy a given predicate is an important problem in debugging and verification of parallel programs. We give a fast algorithm to enumerate all consistent states of a parallel computation that satisfy a stable predicate. In addi- tion, we define a new category of global predicates called count predicates and give an algorithm to enumerate all consistent states (of the computation) that satisfy it. All existing predicate detection algorithms, such as BFS, DFS and Lex algorithms, do not exploit the knowledge about the nature of the predicates, and thus may visit all global states of the computation in the worst case. In comparison, our algorithms only visit the states that satisfy the given predicate, and thus take time and space that is a polynomial function of the number of states of interest. In doing so, they provide a significant reduction — exponential in many cases — in time complexities in comparison to existing algorithms.

Space Efficient Breadth-First and Level Traversals of Consistent Global States of Parallel Programs

Enumerating consistent global states of a computation is a fundamental problem in parallel computing with applications to debugging, testing and runtime verification of parallel programs. Breadth-first search (BFS) enumeration is especially useful for these applications as it finds an erroneous consistent global state with the least number of events possible. The total number of executed events in a global state is called its rank. BFS also allows enumeration of all global states of a given rank or within a range of ranks. If a computation on n processes has m events per process on average, then the traditional BFS (Cooper-Marzullo and its variants) requires \(\mathcal {O}(\frac{m^{n-1}}{n})\) space in the worst case, whereas our algorithm performs the BFS requires \(\mathcal {O}(m^2n^2)\) space. Thus, we reduce the space complexity for BFS enumeration of consistent global states exponentially, and give the first polynomial space algorithm for this task. In our experimental evaluation of seven benchmarks, traditional BFS fails in many cases by exhausting the 2 GB heap space allowed to the JVM. In contrast, our implementation uses less than 60 MB memory and is also faster in many cases.

ActiveMonitor: Asynchronous Monitor Framework for Scalability and Multi-Object Synchronization

Monitor objects are used extensively for thread-safety and synchronization in shared memory parallel programs. They provide ease of use, and enable straightforward correctness analysis. However, they inhibit parallelism by enforcing serial executions of critical sections, and thus the performance of parallel programs with monitors scales poorly with number of processes. Their current design and implementation is also ill-suited for thread synchronization across multiple thread-safe objects. We present ActiveMonitor - a framework that allows multi-object synchronization without global locks, and improves parallelism by exploiting asynchronous execution of critical sections. We evaluate the performance of Java based implementation of ActiveMonitor on micro-benchmarks involving light and heavy critical sections, as well as on single-source-shortest-path problem in directed graphs. Our results show that on most of these problems, ActiveMonitor based programs outperform programs implemented using Javas reentrant-lock and condition constructs.

Necessary and Sufficient Conditions on Partial Orders for Modeling Concurrent Computations

Partial orders are used extensively for modeling and analyzing concurrent computations. In this paper, we define two properties of partially ordered sets: width-extensibility and interleaving-consistency, and show that a partial order can be a valid state based model: (1) of some synchronous concurrent computation iff it is width-extensible, and (2) of some asynchronous concurrent computation iff it is width-extensible and interleaving-consistent. We also show a duality between the event based and state based models of concurrent computations, and give algorithms to convert models between the two domains. When applied to the problem of checkpointing, our theory leads to a better understanding of some existing results and algorithms in the field. It also leads to efficient detection algorithms for predicates whose evaluation requires knowledge of states from all the processes in the system.

RegSOP: A registry for service oriented programming with behavior based discovery

Service Registries form a core component of Services Computing. They have been successful in enabling loose coupling among services by storing, managing and exposing interface descriptions of available services in a standard description language. However, existing service registries fall short of fulfilling the promise of enabling automatic service discovery and invocation and usually are tied to a particular web service technology. We present RegSOP that uses a novel approach of utilizing behavioral descriptions of available services as the basis for registering and discovering services. Behavioral descriptions can be classified and made available to the programmer at development time without committing to any particular service instance or underlying web service technology. Further, RegSOP computes different relationships among service behavior and automatically builds an ontology of service behavior. RegSOP, therefore, reduces the discovery process at runtime to a quick lookup of service classname. We present the design and implementation of RegSOP and report our evaluation of its capabilities.

An Evidence Based Analytical Approach for Process Automation: Case Study in Finance and Administration Process Delivery Services

Process Automation is a critical activity to reduce the need for human work in the production of goods and services to make the processes for uniform and efficient. It is always challenging to make informed decisions on areas for automation which addresses time-to-value to the business. In this paper, we present an evidence based analytics approach to identify top opportunities for process automation, and provide objective assessment of benefit to enable process leaders to take informed decisions. This approach is composed of three major steps. The first step is to identify the top hitters of human intensity in the delivery processes through analyzing evidence gathered from activity time-motion monitoring and onsite process deep dive. The second step is to prioritize the opportunities for automation by analyzing technology choices and estimated business impact. The final step is to assess the benefit through deep analysis on the additional evidence gathered on time-motion data on operational procedures through sampling and extrapolation, and degree of automation can be achieved through technology components. A case study in Finance and Administration Process Delivery Services is used to illustrate the core idea of our analytical approach.