Andrew Haley

Project Loom, an OpenJDK project, is "intended to explore, incubate and deliver Java VM features and APIs built on top of them for the purpose of supporting easy-to-use, high-throughput lightweight concurrency and new programming models on the Java platform." These feature include Lightweight Threads, delimited continuations, and tail-call elimination.

The speaker, a Project Loom team member, will describe the project in depth, in particular the gnarly details of how coroutine and continuation scheduling mechanism works, and a new feature, Scoped Locals.

An open Q&A session with members of the OpenJDK Governing Board.

Other people: Mark Reinhold Mario Torre Georges Saab Doug Lea John Duimovich

An open Q&A session with members of the OpenJDK Governing Board.

An open Q&A session with members of the OpenJDK Governing Board.

Other people: Mark Reinhold Mario Torre Georges Saab Doug Lea John Duimovich

Welcome to the 2018 edition of the Free Java DevRoom!

Other people: Mario Torre

An open Q&A session with members of the OpenJDK Governing Board

Other people: Mark Reinhold Mario Torre Georges Saab Doug Lea

Meet the OpenJDK Governing Board, Q&A session

Other people: Mark Reinhold Georges Saab Doug Lea John Duimovich

Imagine you receive a report of a bug which causes a segfault (i.e. a memory exception) in the HotSpot Java VM very occasionally. This bug only occurs about one time in ten; it might take many hours before it happens. It has only been observed when running one particular piece of proprietary software. It only seems to occur on one large machine when running many concurrent threads and a huge heap. There is a clue: it only seems to happen when running the parallel scavenge garbage collector. But you've no real idea of how the garbage collector works.

This happened to me in 2015. I'm used to being able to find and fix bugs, but this one resisted all of my attempts for a long time. As far as I can recall it's the most difficult bug I've ever fixed. In hunting this bug I used every tool available to me as a HotSpot developer. I'll describe them and how they were used.

We don't much talk about debugging. Many of us spend much of our time doing it, but not talking or writing about this important activity. We should talk about it more. If there's time it would be good to swap war stories.

Meet the OpenJDK Governing Board, Q&A session

Other people: Mark Reinhold Georges Saab

We've been working on OpenJDK for a long time now and we've gained a lot of experience working on the code itself and, perhaps more importantly, working with the Java team inside Oracle. This talk is about our experiences trying make one of the largest ever external contributions to OpenJDK, the AArch64 port.

I'll talk about how the OpenJDK contribution process works, and how it doesn't work, and how important it is to gain the trust of people inside Oracle's Java team. I'll discuss the strange asymmetry of being an external contributor to a project but not being able to know all of what is going on. I'll try my best to explain the baffling role of Projects and JEPs. I'll speculate about the future of OpenJDK and how it must change as more people outside Oracle contribute significant slabs of code, and how we must have more external patch reviewers.

Finally, I'll open up the floor for discussion. I'm sure we'll have a lot to talk about.

What really happens to your Java code along the way to becoming machine code?

Red Hat has been developing an almost pauseless GC for OpenJDK which requires adding read barriers to every object access. We've also developed ARM64 versions of both the server and the client compilers. This has given us quite a bit of experience with the internals of the various methods of generating machine code inside the JVM. This talk will start with a brief tour of the various levels of code generation available and then open up the floor for questions from our panel.

Other people: Roman Kennke Andrew Dinn Christine H Flood

An open Q&A session with members of the OpenJDK Governing Board.

Other people: Mark Reinhold Georges Saab Doug Lea

Red Hat's project of porting OpenJDK to run on ARM's new 64-bit architecture began about 18 months ago. This talk will describe the work we have performed over the last year, explaining how we went about implementing the client and server JIT compilers. In particular, we will give details and examples of how we have tuned the server compiler to generate code that has been optimized to make use of the AArch64 instruction set.

Red Hat's project of porting OpenJDK to run on ARM's new 64-bit architecture began about 18 months ago. Our rapid progress implementing the interpreted runtime was demonstrated at last year's FOSDEM. Since then we have completed our implementation of both the client and server JIT compilers and the project is now approaching its finishing stages. All of which implies that the first high quality, high performance Java runtime available to AArch64 developers will be Free Software.

This talk will describe the work we have performed over the last year, explaining how we went about implementing the two JIT compilers. In particular, we will give details of how we have tuned the server compiler to generate code that has been optimized to make use of the AArch64 instruction set. We will demonstrate the latter by running some example programs, displaying the generated AArch64 machine code and comparing it with the code generated by the x86 JIT compiler.

Other people: Andrew Dinn

An open Q&A session with members of the OpenJDK Governing Board.

Other people: Mark Reinhold Georges Saab Doug Lea

ARM's new, 64 bit ARMv8 architecture, is a break from the past in two regards. The change of scale from 32 to 64 bit implies a broadening of ARM's target market from (mostly) embedded devices to address the requirements of high end consumer devices and servers. The 64 bit mode (AArch64) programming model is significantly different from the existing 32 bit model. If ARM's change of direction does indeed grab a significant share of this market then there are two corresponding implications for the Free Java community. We need a high quality free Java implementation to ensure that the market is not colonised solely by commercial Java vendors. We need to provide this implementation from scratch rather than try to modify existing 32 bit Java implementations. Red Hat has decided to port OpenJDK to AArch64 precisely to meet these implications head on.

This talk will describe the significant progress we have made in porting OpenJDK to AArch64 since the project began in earnest in July 2012, even though real hardware is not yet available and will not be for many months to come.

During the talk we will:

outline our plan for converting the runtime JIT components of OpenJDK to generate AArch64 code -- the (generated AArch64 code) template interpreter and the C1/C2 JIT compilers

explain how we have already managed to execute and debug generated ARM code using our own ARMv8 functional simulator integrated into an x86 JVM

display execution of a Java program using the template interpreter running on our simulator

show both ARM instruction-level and Java bytecode-level stepping and debugging of generated code within gdb

Other people: Andrew Dinn

Open community discussion on the future of Free Java we would like to see.

This talk will cover progress with OpenJDK on ARM. It's basically a progress report, but with some technical detail about the changes needed for: * The new Hard FP ABI. * ARM 7. I'll also discuss the issues that arise from the Java Memory Model (also known as JSR 233.) The talk will then be in two halves, one part being very specific to Ed Nevill's ARM Assembler interpreter and JIT, and the other part will cover the ARM more generally. If there's any time left I'll also cover the upcoming ARM8 architecture.

Brief Welcome to the Free Java DevRoom

Other people: Andrew Hughes Ben Evans Dalibor Topić Mario Torre Mark Wielaard Martijn Verburg Sylvestre Ledru Tom Marble