Tech Talk 1: Garbage Collection for Latency Sensitive Big Data Applications
Latency sensitive services such as credit-card fraud detection and website targeted advertisement rely on Big Data platforms which run on top of memory managed runtimes, such as the Java Virtual Machine (JVM). These platforms, however, suffer from unpredictable and unacceptably high pause times due to inadequate memory management decisions (e.g., allocating objects with very different lifetimes next to each other, resulting in severe memory fragmentation). This leads to frequent and long application pause times, breaking Service Level Agreements (SLAs). Previous works reduce such application pauses by allocating objects in off-heap, in special allocation regions/generations, or by using ultra-low latency Garbage Collectors (GC). However, all these
solutions either require a combination of programmer effort and
knowledge, source code access, offline profiling (with clear negative impacts on programmer’s productivity), or impose a significant impact on application throughput and/or memory to reduce application pauses. We propose ROLP, a Runtime Object Lifetime Profiler that profiles application code at runtime and helps pretenuring GC algorithms allocating objects with similar lifetimes close to each other so that the overall fragmentation, GC effort, and application pauses are reduced. ROLP is implemented for the OpenJDK 8 and results show significant tail latencies reductions with negligible throughput and memory overheads,
with no programmer effort, and no source code access.
Rodrigo recently joined the ETHZ Systems Group after finishing his PhD in Information Systems and Computer Engineering from Instituto Superior Técnico (IST), University of Lisbon. His research is mostly focused on runtime systems design and implementation with a special focus on memory management and Just-In-Time compilation. In recent years, Rodrigo has worked with companies such as Microsoft Research, Google, Feedzai, and Jelastic, and has contributed to open source projects such as OpenJDK HotSpot JVM, CRIU (checkpoit-restore for Linux), and Dora (academic runtime system).
Tech Talk 2: Safe and Efficient Execution of LLVM-based Languages on the Java Virtual Machine
In unsafe languages like C/C++, errors such as buffer overflows cause undefined behavior. Typically, compilers handle undefined behavior in some arbitrary way, for example, they disregard it when optimizing and omit inserting checks that could detect it, which often results in hard-to-find bugs and security vulnerabilities. To tackle undefined behavior, we came up with an approach to execute unsafe languages on the Java Virtual Machine. We implemented this approach as Safe Sulong, a system that includes an interpreter for unsafe languages, which is written in Java. By relying on Java’s well-definedness and its automatic run-time checks, the interpreter can detect buffer overflows and other errors during its execution and can terminate the program in such cases. Our evaluation indicates that Safe Sulong’s performance is comparable to the performance of bug-finding tools with similar capabilities, and, for some benchmarks, even reaches the performance of machine code produced by optimizing compilers such as Clang. Furthermore, we evaluated Safe Sulong in terms of effectiveness and found that it can detect bugs that are overlooked by other tools.
Bio: Manuel Rigger is a postdoc at ETH Zurich in the Advanced Software Technologies (AST) Lab, mentored by Zhendong Su. He is working on software robustness, programming language implementation, system security, and software-repository mining. Manuel completed his PhD at Johannes Kepler University Linz, mentored by Hanspeter Mössenböck. As part of his dissertation, he developed Sulong, a system to safely execute LLVM-based languages on the Java Virtual Machine.
Where: ETH Zurich, CAB, E72