llvm dev - Mar 2019 - ETH Zurich Compiler Social - 14th March - JVM: Latency Sensitive GC & Safe Execution of LLVM-IR

Dear all,

Thursday 14th March, 19:00, we have two exciting tech talks about the JVM, given
by fellow ETH Post-docs Rodrigo Bruno and Manuel Rigger.

**Garbage Collection for Latency Sensitive Big Data Applications**

Abstract:
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.

Bio:
Rodrigo Bruno 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 (checkpoint-restore
for Linux), and Dora (academic runtime system).

**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.

# Registration

https://www.meetup.com/llvm-compiler-and-code-generation-socials-zurich/events/vxmqlqyzfbsb/

# What

A social meetup to discuss compilation and code generation questions with a
focus on LLVM, clang, Polly and related projects.

Our primary focus is to provide a venue (and drinks & snacks) that enables
free discussions between interested people without imposing an agenda/program.
This is a great opportunity to informally discuss your own projects, get project
ideas or just learn about what people at  ETH and around Zurich are doing with
LLVM.

# Who:  - Anybody interested -

  - ETH students and staff
  - LLVM developers and enthusiasts external to ETH

# When:  14.03.2018, 19:00

# Where: CAB E 72, ETH Zurich

# Earlier Socials

We have videos of earlier socials available at:
http://pollylabs.org/llvm-social-zurich.html

Best,
Tobias