Showing papers by "Mayur Naik published in 2012"

Automated concolic testing of smartphone apps

Abstract: We present an algorithm and a system for generating input events to exercise smartphone apps. Our approach is based on concolic testing and generates sequences of events automatically and systematically. It alleviates the path-explosion problem by checking a condition on program executions that identifies subsumption between different event sequences. We also describe our implementation of the approach for Android, the most popular smartphone app platform, and the results of an evaluation that demonstrates its effectiveness on five Android apps.

Computing in cirrus clouds: the challenge of intermittent connectivity

Abstract: Mobile devices are increasingly being relied on for tasks that go beyond simple connectivity and demand more complex processing. The primary approach in wide use today uses cloud computing resources to off-load the "heavy lifting" to specially designated servers when they are well connected. In reality, a mobile device often encounters, albeit intermittently, many entities capable of lending computational resources. In this work-in-progress paper we first give an overview of this environment, which we call a Cirrus Cloud due to its intermittent connectivity feature, and explain how it provides a spectrum of computational contexts for remote computation in a mobile environment. An ultimately successful system will need to have the flexibility to handle intermittent connectivity and use a mix of options on that spectrum. We investigate two scenarios at the extremes of the spectrum: 1) a scenario where a mobile device experiences intermittent connectivity to a central cloud computing resource, and 2) a scenario where a mobile device off-loads computation to other mobile devices it might meet intermittently. We present preliminary designs, implementations, and evaluations of systems that enable a mobile application to use remote computational resources to speedup computing and conserve energy in these scenarios. The preliminary results show the effectiveness of our systems and demonstrate the potential of computing in Cirrus Clouds.

Abstractions from tests

Abstract: We present a framework for leveraging dynamic analysis to find good abstractions for static analysis. A static analysis in our framework is parametrised. Our main insight is to directly and efficiently compute from a concrete trace, a necessary condition on the parameter configurations to prove a given query, and thereby prune the space of parameter configurations that the static analysis must consider. We provide constructive algorithms for two instance analyses in our framework: a flow- and context-sensitive thread-escape analysis and a flow- and context-insensitive points-to analysis. We show the efficacy of these analyses, and our approach, on six Java programs comprising two million bytecodes: the thread-escape analysis resolves 80% of queries on average, disproving 28% and proving 52%; the points-to analysis resolves 99% of queries on average, disproving 29% and proving 70%.

Scalable Parametric Static Analysis

Abstract: Parametric static analysis allows choosing a parameter value to balance the precision and cost of the instantiated analysis. We propose an efficient approach to either find a cheapest parameter value to prove a given query or show that no such parameter value exists. Our approach is based on refinement, as in CEGAR (counterexample-guided abstraction refinement), but applies a novel meta-analysis to abstract counterexample traces to efficiently find parameter values that are incapable of proving the query. We formalize our approach in a generic framework and apply it to two parametric analyses: a thread-escape analysis and a type-state analysis. The thread-escape analysis is implemented and applied to eight Java benchmarks comprising 2.5 MLOC. Our experiments show that our approach is effective in practice: for our four largest benchmarks, searching 2 parameter values for each of 10K queries on average per benchmark, it finds a cheapest one for proving 46% queries and shows that none exists for 37% queries, in one minute per query on average.