Logo des Repositoriums

Auflistung nach Autor:in "Binder, Walter"

1 - 7 von 7
  • Konferenzbeitrag
    Accurate profiling in the presence of dynamic compilation
    (Software Engineering 2016, 2016) Zheng, Yudi; Bulej, Lubomír; Binder, Walter
    Many programming languages are implemented on top of a managed runtime system, such as the Java Virtual Machine (JVM) or the .NET CLR, featuring an optimizing dynamic (just-intime) compiler. Programs written in those languages are first interpreted (or compiled by a baseline compiler), whereas frequently executed methods are later compiled by the optimizing dynamic compiler. Common feedback-directed optimizations [AHR02] performed by state-of-the-art dynamic compilers, such as the optimizing compiler in the Jikes RVM [Ar00] or Graal [Op], include method inlining and stack allocation of objects based on (partial) escape analysis [Ch99, SWM14], amongst others. Such optimizations result in compiled machine code that does not perform certain operations present at the bytecode level. In the case of inlining, method invocations are removed. In the case of stack allocation, heap allocations are removed and pressure on the garbage collector is reduced. Many profiling tools are implemented using bytecode instrumentation techniques, inserting profiling code into programs at the bytecode level. However, because dynamic compilation is transparent to the instrumented program, a profiler based on bytecode instrumentation techniques is not aware of the optimizations performed by the dynamic compiler. Prevailing profilers based on bytecode instrumentation suffer from two serious limitations: (1) over-profiling of code that is optimized (and in the extreme case completely removed) by the dynamic compiler, and (2) perturbation of the compiler optimizations due to the inserted instrumentation code. We present a novel technique to make profilers implemented with bytecode instrumentation techniques aware of the optimization decisions of the dynamic compiler, and to make the dynamic compiler aware of inserted profiling code. Our technique enables profilers which collect dynamic metrics that (1) correspond to an execution of the base profiling (w.r.t. the applied compiler optimizations), and (2) properly reflect the impact of dynamic compiler optimizations. We implement our approach in a state-of-the-art Java virtual machine and demonstrate its significance with concrete profilers. We quantify the impact of escape analysis on allocation profiling, object lifetime analysis, and the impact of method inlining on callsite profiling. We illustrate how our approach enables new kinds of profilers, such as a profiler for non-inlined callsites, and a testing framework for locating performance bugs in dynamic compiler implementations. This work was originally presented at OOPSLA'15 [ZBB15], where it received a Distinguished Paper Award as well as an endorsement from the Artifact Evaluation Committee for having submitted an easy-to-use, well-documented, consistent, and complete artifact4. In the meantime, the work has been integrated into the Graal project.
  • Konferenzbeitrag
    Analysis and Optimization of Task Granularity on the Java Virtual Machine
    (Software Engineering 2020, 2020) Rosà, Andrea; Rosales, Eduardo; Binder, Walter
    Our article published in ACM Transactions on Programming Languages and Systems (TOPLAS) (which extends our work published in the proceedings of the 2018 IEEE/ACM International Symposium on Code Generation and Optimization (CGO 2018))presents a new methodology to accurately and efficiently collect the granularity of each executed task. Task granularity, i.e., the amount of work performed by parallel tasks, is a key performance attribute of parallel applications. On the one hand, fine-grained tasksmay introduce considerable parallelization overheads. On the other hand, coarse-grained tasks may not fully utilize the available CPU cores, leading to missed parallelization opportunities. We implement our methodology in tgp, a novel task-granularity profiler that collects carefully selected metrics from the whole system stack with low overhead, and helps developers locate performance and scalability problems. We analyze task granularity in the DaCapo, ScalaBench, and Spark Perf benchmark suites, revealing inefficiencies related to fine-grained and coarse-grained tasks in several applications We demonstrate that the collected task-granularity profiles are actionable by optimizing task granularity in several applications, achieving speedups up to a factor of 5.9x. tgp is available open-source at https://github.com/fithos/tgp/
  • ConferencePaper
    Automated Large-scale Multi-language Dynamic Program Analysis in the Wild
    (Software Engineering 2021, 2021) Villazón, Alex; Sun, Haiyang; Rosà, Andrea; Rosales, Eduardo; Bonetta, Daniele; Defilippis, Isabella; Oporto, Sergio; Binder, Walter
    Our paper published in the proceedings of the 33rd European Conference on Object-Oriented Programming (ECOOP 2019) proposes NAB, a novel framework to execute custom dynamic analysis on open-source software hosted in public repositories. The publication is complemented by an accepted artifact. Analyzing today’s large code repositories has become an important research area for understanding and improving different aspects of modern software systems. Despite the presence of a large body of work on mining code repositories through static analysis, studies applying dynamic analysis to open-source projects are scarce and of limited scale. Nonetheless, being able to apply dynamic analysis to the projects hosted in public code repositories is fundamental for large-scale studies on the runtime behavior of applications, which can greatly benefit the programming-language and software-engineering communities. NAB is fully automatic, language-agnostic, and scalable. We describe NAB’s key features and architecture. We also present three case studies on more than 56K Node.js, Java, and Scala projects, enabling us to 1) understand how developers use JavaScript Promises, 2) identify bad coding practices in JavaScript applications, and 3) locate task-parallel Java and Scala workloads suitable for inclusion in a domain-specific benchmark suite. A preliminary version of NAB is available at http://dag.inf.usi.ch/software/nab/
  • Konferenzbeitrag
    Comprehensive multi-platform dynamic program analysis for the Java and dalvik virtual machines
    (Software-engineering and management 2015, 2015) Binder, Walter; Zheng, Yudi; Bulej, Lubomír; Sun, Haiyang; Tuma, Petr
    Despite its importance for many software engineering tasks, dynamic program analysis is only insufficiently supported on the Java platform [KABM12]. Ex- isting Java Virtual Machines (JVMs) as well as Android's Dalvik Virtual Machine (DVM) lack dedicated mechanisms for expressing arbitrary dynamic program analysis tasks at a high abstraction level, for ensuring complete code coverage of the analysis, and for isolating analysis tasks from the observed program to prevent interference. For example, the JVM Tool Interface requires analysis tasks to be written in low-level native code, and some virtual machines (e.g., DVM) do not support it. As a consequence, dynamic program analysis tools are often implemented using low-level mechanisms, resulting in error-prone code that is difficult to maintain, and support only a particular virtual machine. Moreover, many analysis tools produce unsound profiles (due to interference of the analysis with the observed program) or incomplete profiles (due to limited code coverage).
  • Konferenzbeitrag
    Optimal workflow execution in Grid environments
    (NODe 2005 – GSEM 2005, 2005) Binder, Walter; Constantinescu, Ion; Faltings, Boi; Heterd, Nadine
  • Konferenzbeitrag
    Portable profiling of memory allocation in Java
    (NODe 2005 – GSEM 2005, 2005) Binder, Walter
  • Konferenzbeitrag
    Renaissance: Benchmarking Suite for Parallel Applications on the JVM
    (Software Engineering 2020, 2020) Prokopec, Aleksandar; Rosà, Andrea; Leopoldseder, David; Duboscq, Gilles; Tu̇ma, Petr; Studener, Martin; Bulej, Lubomír; Zheng, Yudi; Villazón, Alex; Simon, Doug; Würthinger, Thomas; Binder, Walter
    Our paper published in the proceedings of the 40th ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2019)proposes Renaissance, a modern benchmark suite whose aim is to advance compiler and virtual machine (VM) research. The publication is complemented by an accepted artifactTo demonstrate that a compiler optimization, a memory management algorithm, or a synchronization technique is useful, a VM researcher needs benchmarks that demonstrate the desired behavior, and at the same time capture representative aspects of real-world applications. During the last decade, multiple new programming paradigms appeared on the Java VM (JVM), including functional programming, big-data processing, parallel and concurrent programming, message-passing, stream processing, and machine learning. The JVM has evolved as a platform too: new features, such as method-handles, variable-handles, the invokedynamic instruction, lambdas, atomic and relaxed memory operations, present new challenges for dynamic compilers and runtime environments. Existing benchmark suites do not capture the new applications, because they were made in a time when these workloads did not exist. Renaissance bridges this gap. The Renaissance suite is an ongoing, open-source effort to collect representative real-world workloads, and to advance the research and development of VMs. Renaissance is available at https://renaissance.dev/