Browsing by Autor "Walter Binder"

Now showing 1 - 15 of 15

A programming model and framework for comprehensive dynamic analysis on Android
(2015) Haiyang Sun; Yudi Zheng; Lubomír Bulej; Alex Villazón; Zhengwei Qi; Petr Tůma; Walter Binder
The multi-process architecture of Android applications combined with the lack of suitable APIs make dynamic program analysis (DPA) on Android challenging and unduly difficult. Existing analysis tools and frameworks are tailored mainly to the needs of security-related analyses and are not flexible enough to support the development of generic DPA tools. In this paper we present a framework that, besides providing the fundamental support for the development of DPA tools for Android, enables development of cross-platform analyses that can be applied to applications targeting the Android and Java platforms. The framework provides a convenient high-level programming model, flexible instrumentation support, and strong isolation of the base program from the analysis. To boost developer productivity, the framework retains Java as the main development language, while seamless integration with the platform overcomes the recurring obstacles hindering development of DPA tools for Android. We evaluate the framework on two diverse case studies, demonstrating key concepts, the flexibility of the framework, and analysis portability.
Automated Large-Scale Multi-Language Dynamic Program Analysis in the Wild (Artifact)
(Schloss Dagstuhl – Leibniz Center for Informatics, 2019) Alex Villazón; Haiyang Sun; Andrea Rosà; Eduardo Rosales; Daniele Bonetta; Isabella Defilippis; Sergio Oporto; Walter Binder
This artifact provides a preliminary release of NAB, a distributed infrastructure for executing large-scale dynamic program analyses (DPAs). The artifact consists of ready-to-use Docker containers that allow one to run different DPA tools (Deep-Promise, JITProf, and tgp) on Node.js, Java, and Scala projects hosted on GitHub. The artifact enables the reproduction of the figures and tables of the related paper "Automated Large-scale Multi-language Dynamic Program Analysis in the Wild" with pre-collected data (several GBs) and the execution of DPAs on specific sets of GitHub projects.
Automated Large-Scale Multi-Language Dynamic Program Analysis in the Wild (Tool Insights Paper)
(Schloss Dagstuhl – Leibniz Center for Informatics, 2019) Alex Villazón; Haiyang Sun; Andrea Rosà; Eduardo Rosales; Daniele Bonetta; Isabella Defilippis; Sergio Oporto; Walter Binder
Today’s availability of open-source software is overwhelming, and the number of free, ready-to-use software components in package repositories such as NPM, Maven, or SBT is growing exponentially. In this paper we address two straightforward yet important research questions: would it be possible to develop a tool to automate dynamic program analysis on public open-source software at a large scale? Moreover, and perhaps more importantly, would such a tool be useful? We answer the first question by introducing NAB, a tool to execute large-scale dynamic program analysis of open-source software in the wild. NAB is fully-automatic, language-agnostic, and can scale dynamic program analyses on open-source software up to thousands of projects hosted in code repositories. Using NAB, we analyzed more than 56K Node.js, Java, and Scala projects. Using the data collected by NAB we were able to (1) study the adoption of new language constructs such as JavaScript Promises, (2) collect statistics about bad coding practices in JavaScript, and (3) identify Java and Scala task-parallel workloads suitable for inclusion in a domain-specific benchmark suite. We consider such findings and the collected data an affirmative answer to the second question.
Capturing Inter-process Communication for Runtime Verification on Android
(Springer Science+Business Media, 2018) Alex Villazón; Haiyang Sun; Walter Binder
Characterizing Java Streams in the Wild
(2022) Eduardo Rosales; Andrea Rosà; Matteo Basso; Alex Villazón; Adriana Orellana; Angel Zenteno; Jhon Rivero; Walter Binder
Since Java 8, streams ease the development of data transformations using a declarative style based on functional programming. Some recent studies aim at shedding light on how streams are used. However, they consider only small sets of applications and mainly apply static analysis techniques, leaving the large-scale analysis of dynamic metrics focusing on stream processing an open research question. In this paper, we present the first large-scale empirical study on the use of streams in Java. We present a novel dynamic analysis for collecting runtime information and key metrics that enable the fine-grained characterization of sequential and parallel stream processing. We massively apply our dynamic analysis using a fully automated approach, supported by a distributed infrastructure to mine public software projects hosted on GitHub. Our findings advance the understanding of the use of streams, both confirming some of the results of previous studies at a much larger scale, as well as revealing previously unobserved findings in the use of streams.
Design Space Exploration of Object Caches with Cross-Profiling
(2011) Martin Schoeberl; Walter Binder; Alex Villazón
To avoid data cache trashing between heap-allocated data and other data areas, a distinct object cache has been proposed for embedded real-time Java processors. This object cache uses high associativity in order to statically track different object pointers for worst-case execution-time analysis. However, before implementing such an object cache, an empirical analysis of different organization forms is needed. We use a cross-profiling technique based on aspect-oriented programming in order to evaluate different object cache organizations with standard Java benchmarks. From the evaluation we conclude that field access exhibits some temporal locality, but almost no spatial locality. Therefore, filling long cache lines on a miss just introduces a high miss penalty without increasing the hit rate enough to make up for the increased miss penalty. For an object cache, it is more efficient to fill individual words within the cache line on a miss.
DiSL
(2012) Lukáš Marek; Alex Villazón; Yudi Zheng; Danilo Ansaloni; Walter Binder; Zhengwei Qi
Many dynamic analysis tools for programs written in managed languages such as Java rely on bytecode instrumentation. Tool development is often tedious because of the use of low-level bytecode manipulation libraries. While aspect-oriented programming (AOP) offers high-level abstractions to concisely express certain dynamic analyses, the join point model of mainstream AOP languages such as AspectJ is not well suited for many analysis tasks and the code generated by weavers in support of certain language features incurs high overhead. In this paper we introduce DiSL (domain-specific language for instrumentation), a new language especially designed for dynamic program analysis. DiSL offers an open join point model where any region of bytecodes can be a shadow, synthetic local variables for efficient data passing, efficient access to comprehensive static and dynamic context information, and weave-time execution of user-defined static analysis code. We demonstrate the benefits of DiSL with a case study, recasting an existing dynamic analysis tool originally implemented in AspectJ. We show that the DiSL version offers better code coverage, incurs significantly less overhead, and eases the integration of new analysis features that could not be expressed in AspectJ.
Exploiting Dynamic Information in IDEs Improves Speed and Correctness of Software Maintenance Tasks
(IEEE Computer Society, 2012) David Röthlisberger; Marcel Harry; Walter Binder; Philippe Moret; Danilo Ansaloni; Alex Villazón; Oscar Nierstrasz
Modern IDEs such as Eclipse offer static views of the source code, but such views ignore information about the runtime behavior of software systems. Since typical object-oriented systems make heavy use of polymorphism and dynamic binding, static views will miss key information about the runtime architecture. In this paper, we present an approach to gather and integrate dynamic information in the Eclipse IDE with the goal of better supporting typical software maintenance activities. By means of a controlled experiment with 30 professional developers, we show that for typical software maintenance tasks, integrating dynamic information into the Eclipse IDE yields a significant 17.5 percent decrease of time spent while significantly increasing the correctness of the solutions by 33.5 percent. We also provide a comprehensive performance evaluation of our approach.
Flexible and efficient profiling with aspect‐oriented programming
(Wiley, 2011) Walter Binder; Danilo Ansaloni; Alex Villazón; Philippe Moret
Abstract Many profilers for virtual execution environments, such as the Java virtual machine (JVM), are implemented with low‐level bytecode instrumentation techniques, which is tedious, error‐prone, and complicates maintenance and extension of the tools. In order to reduce the development time and cost, we promote building profilers for the JVM using high‐level aspect‐oriented programming (AOP). We show that the use of aspects yields concise profilers that are easy to develop, extend, and maintain, because low‐level instrumentation details are hidden from the tool developer. In order to build efficient profilers, we introduce inter‐advice communication, an extension to common AOP languages that enables efficient data passing between advices that are woven into the same method using local variables. We illustrate our approach with two case studies. First, we show that an existing, instrumentation‐based tool for listener latency profiling can be easily recast as an aspect. Second, we present an aspect for comprehensive calling context profiling. In order to reduce profiling overhead, our aspect parallelizes application execution and profile creation, resulting in a speedup of 110% on a machine with more than two cores, compared with a primitive, non‐parallel approach. Copyright © 2011 John Wiley & Sons, Ltd.
JP2
(2011) Aibek Sarimbekov; Walter Binder; Andreas Sewe; Mira Mezini; Alex Villazón
The collection of dynamic metrics is an important part of performance analysis and workload characterization. We demonstrate JP2, a new tool for collecting dynamic bytecode metrics for standard Java Virtual Machines (JVMs). The application of JP2 is a three-step process: First, an online step instruments the application for profiling. Next, the resulting profile is dumped in an appropriate format for later analysis. Finally, the desired metrics are computed in an offline step. JP2's profiles capture both the inter-procedural and the intra-procedural control flow in a callsite-aware calling-context tree, where each node stores, amongst others, the execution count for each basic block of code. JP2 uses portable bytecode instrumentation techniques, is Open Source, and has been tested with several production JVMs.
JUniVerse
(2019) Omar Javed; Alex Villazón; Walter Binder
Current approaches for analyzing large number of open-source projects mainly focus on data mining or on static analysis techniques. On the contrary, research applying dynamic analyses such as Runtime Verification (RV) to open-source projects is scarce. This is due to lack of automatic means for executing arbitrary pieces of software that rely on complex dependencies and input parameters. In this paper, we present a fully automated infrastructure, JUniVerse, to conduct large-scale studies on unit tests in open-source projects in the wild. The proposed infrastructure runs on a cluster for parallel execution. We demonstrate the effectiveness of JUniVerse by conducting a large-scale study on Java projects hosted on GitHub. We apply a selection criteria based on static analysis to select 3 490 active projects. To show the feasibility of JUniVerse, we choose RV as a case study, and investigate the applicability of 182 publicly available JavaMOP specifications to the code exercised by unit tests. Our study reveals that 37 (out of 182) specifications (i.e., 20%) are not applicable to the code exercised by unit tests of real-world projects. Finally, with JUniVerse, we are able to identify a set of specs and projects for future RV studies.
MAJOR: AN ASPECT WEAVER WITH FULL COVERAGE SUPPORT
(2011) Alex Villazón; Walter Binder; Danilo Ansaloni
Prevailing Aspect-Oriented Programming (AOP) frameworks for Java, such as AspectJ, use bytecode instrumentation techniques to weave aspects into application code. Unfortunately, those frameworks do not support weaving in the Java class library. When implementing aspect-based tools, such as profilers, debugger, or dynamic program analysis tools in general, the aforementioned restriction becomes an important limitation for successfully applying AOP.In this article we present MAJOR, an aspect weaver with full coverage support. That is, MAJOR ensures that aspects are woven into all classes loaded in a Java Virtual Machine, including those in the standard Java class library. We describe the intricacies of instrumentation of the Java class library and present an extended instrumentation approach allowing the user to choose between a pure Java weaving solution based on a two-phases instrumentation scheme, or a single-phase one requiring a tiny native code layer. The single-phase approach allows to better isolate the weaving process from the execution of the woven code.
NAB: automated large-scale multi-language dynamic program analysis in public code repositories
(2019) Alex Villazón; Haiyang Sun; Andrea Rosà; Eduardo Rosales; Daniele Bonetta; Isabella Defilippis; Sergio Oporto; Walter Binder
This paper describes NAB, a novel framework to execute custom dynamic analysis on open-source software hosted in public repositories. NAB is fully-automatic, language-agnostic and scalable. We present NAB's key features and its architecture. We also discuss three large-scale case studies enabled by NAB on more than 56K Node.js, Java, and Scala projects
Turbo DiSL: Partial Evaluation for High-Level Bytecode Instrumentation
(Springer Science+Business Media, 2012) Yudi Zheng; Danilo Ansaloni; Lukáš Marek; Andreas Sewe; Walter Binder; Alex Villazón; Petr Tůma; Zhengwei Qi; Mira Mezini
Visualizing and exploring profiles with calling context ring charts
(Wiley, 2010) Philippe Moret; Walter Binder; Alex Villazón; Danilo Ansaloni; Abbas Heydarnoori
Abstract Calling context profiling is an important technique for analyzing the performance of object‐oriented software with complex inter‐procedural control flow. The Calling Context Tree (CCT) is a common data structure that stores dynamic metrics, such as CPU time, separately for each calling context. As CCTs may comprise millions of nodes, there is a need for a condensed visualization that eases the localization of performance bottlenecks. In this article, we discuss Calling Context Ring Charts ( CCRCs ), a compact visualization for CCTs, where callee methods are represented in ring segments surrounding the caller's ring segment. In order to reveal hot methods, their callers, and callees, the ring segments can be sized according to a chosen dynamic metric. We describe two case studies where CCRCs help us to detect and fix performance problems in applications. A performance evaluation also confirms that our implementation can efficiently handle large CCTs. Copyright © 2010 John Wiley & Sons, Ltd.