Joel Sikström

About

Sat, 08 Aug 2026 00:00:00 +0000

I’m Joel, a Software Engineer with a MSc in Computer and Information Engineering from Uppsala University (Civilingenjör i Informationsteknologi). I am currently working in the Webex team at Cisco, developing the Webex communications platform for non-embedded platforms. I’ve previously been working in the Java Platform Group at Oracle, developing the HotSpot JVM as part of the (Z)GC team.

The content on this blog represents my personal opinions and does not necessarily reflect the views of my employer.

OpenJDK Contributions

Sun, 02 Aug 2026 00:00:00 +0000

I’m an OpenJDK Reviewer mainly focused on the Garbage Collection (GC) subsystem(s), with an emphasis on ZGC. You can see my active roles in the OpenJDK Community Census https://openjdk.org/census#jsikstro.

Contributions

You can find the bulk of my OpenJDK contributions in the following links:

Mainline PRs: https://github.com/openjdk/jdk/pulls?q=author:jsikstro
Valhalla PRs: https://github.com/openjdk/valhalla/pulls?q=author:jsikstro

Projects

My largest contribution is leading an effort to redesign ZGC’s memory allocation layer to address virtual address space fragmentation. This work has internally been dubbed the Mapped Cache, for its inclusion of a cache for mapped memory.

OpenJDK NMethod Entry Barriers

Sun, 05 Jul 2026 00:00:00 +0000

An nmethod, which I’ll refer to as NMethod, is HotSpot’s representation of a natively compiled Java method, the result of a JIT compilation, typically produced by the C1 or C2 compilers. NMethods are interesting because they require cooperation from the Garbage Collector (GC) to execute efficiently while fitting into Java’s automatic memory management model.

In this post, we’ll deep dive into how NMethods are designed and the mechanism used to enable concurrent execution and cooperation between application threads and GC workers. We’ll cover things like barriers (multiple kinds!), x86 and AArch64 assembly, self- and cross-modifying code, data dependencies, and much more. The underlying theory in this area is a gold mine of interesting technical stuff!

Agentic AI Workflows for OpenJDK Development

Sat, 23 May 2026 00:00:00 +0000

Details and reflections on how I’ve been using AI to approach OpenJDK development

JIT Compilers and Cache Coherency

Tue, 14 Apr 2026 00:00:00 +0000

Deep-dive into cache coherency considerations for JIT compilers on AArch64

Why is my first C++ (m)allocation always 72 KB?

Sat, 28 Feb 2026 00:00:00 +0000

Why is my first C++ (m)allocation always 72 KB?? It’s the ’emergency pool’ for exceptions, here’s how I uncovered it using GDB and digging through the source code of libstdc++, glibc and Valgrind!

Optimizing Java Class Metadata in Project Valhalla

Tue, 03 Feb 2026 00:00:00 +0000

Introduction

While digging into Project Valhalla, I encountered a subtle part of the JVM that turned out to be a prime opportunity for optimization. This exploration led to an approach that shaves unused memory from Java class instance metadata.

In this post, I’ll walk through some of the behind-the-scenes details of one of Project Valhalla’s core features: value classes, and the concept of flattening (or inlining, the term I will use here). Whether you’re a JVM developer or just deeply curious about how Java works under the hood, this technical deep dive is for you.

NUMA-Aware Relocation in ZGC

Thu, 18 Sep 2025 00:00:00 +0000

NUMA-aware relocation is a feature recently added to ZGC, one of the garbage collectors in OpenJDK, with the introduction of JDK-8359683, set to release in JDK 26. Building on the recent memory allocation overhaul (see “How ZGC allocates memory for the Java heap”), this feature further enhances NUMA support and optimization in ZGC. For those interested in the code changes, see the relevant GitHub pull request.

This post is a technical deep dive into how NUMA is incorporated into the Relocation phase of ZGC. We’ll start with some background on the Relocation phase, to provide context for both the domain and the previous non-NUMA implementation. From there, we’ll explore why NUMA matters for GC performance and walk through the details of how NUMA-aware relocation is implemented in practice.

How MADV_COLLAPSE chooses a NUMA node

Fri, 05 Sep 2025 00:00:00 +0000

Introduction

MADV_COLLAPSE is a madvise(2) advice (added in Linux 6.1) that requests a best-effort, synchronous collapse of native pages in a range into Transparent Huge Pages (THPs). As the man page states:

Perform a best-effort synchronous collapse of the native pages mapped by the memory range into Transparent Huge Pages (THPs). MADV_COLLAPSE operates on the current state of memory of the calling process and makes no persistent changes or guarantees on how pages will be mapped, constructed, or faulted in the future.

How ZGC allocates memory for the Java heap

Wed, 16 Apr 2025 00:00:00 +0000

This post explores how ZGC, one of the garbage collectors in the OpenJDK, allocates memory for the Java heap, focusing on enhancements introduced in JDK-8350441 with the Mapped Cache. A garbage collector does much more than just collect garbage - and that’s what I want to unpack in this post. Whether you’re a Java nerd yearning for details, a GC enthusiast, or just curious about how ZGC uses memory behind the scenes, this deep dive is for you.

Dynamic DNS failure with ddclient and Namecheap

Sat, 22 Mar 2025 00:00:00 +0000

TLDR; If you are experiencing similar issues, upgrade to the latest version of ddclient or change IP-check website to something other than dynamicdns.park-your-domain.com. See Discussion.

Backstory

On the morning of 22/3 I noticed that my website was down. My first thought was maybe the power went out and my server never rebooted, but no, it was running perfectly. The next thing I checked was my domain configuration, which I’ve had issues pop up randomly with before. When I pinged my domain I noticed a very strange IP address being resolved (an address in China) [1].

Inspecting OpenJDK performance on Linux using perf

Sun, 16 Feb 2025 00:00:00 +0000

Analyzing performance can be challenging, especially when diagnosing regressions. Finding the right methods to investigate performance issues is often time-consuming and complex. You may have heard of perf, a powerful Linux tool for performance measurement, available from the kernel.

This post will guide you through using perf to analyze performance on Linux, serving as a practical “quick start” guide for those new to profiling Java applications with perf. It’s not meant to be a comprehensive tutorial, as many of those already exist in the extensive documentation of perf and other excellent sources. However, the examples provided may be all you need or, at the very least, give you an idea of where to look for deeper insights.

Huge Pages on Linux

Sat, 19 Oct 2024 00:00:00 +0000

When I first found out about huge pages I was a bit confused. Why do we need larger pages? How do I configure this? Is it always on? I had many questions. The first thing you should know is that the concept of larger pages has many names, although they all achieve the same thing: increase the page size, usually to something larger than 4096 bytes (4 KB), which is the default on many systems.

How to install OpenJDK on Windows

Mon, 07 Oct 2024 00:00:00 +0000

Download

Start by navigating to https://jdk.java.net/ and download the latest build. At the time of writing, JDK23 is the latest version and can be found at https://jdk.java.net/23/.

Download the zip file shown next to Windows/x64. Although you could unzip the contents anywhere on your computer, I recommend that you should place them in C:\Program Files\OpenJDK, inside a folder named the same way the current JDK version is. Since I am downloading JDK23, I will unzip the contents of the zip file into C:\Program Files\OpenJDK\23\.

University Projects

Wed, 03 Jul 2024 00:00:00 +0000

In June 2024 I graduated from the Master’s Programme in Computer and Information Engineering at Uppsala University. These are some of the projects I have done during my studies.

jsmalloc @ Oracle (Master’s Thesis)

Adapted TLSF memory allocator for use in ZGC, a garbage collector in the HotSpot Java Virtual Machine.

Available on GitHub

Overview on inside.java

Full report

Admirals

Game Engine for developing 2D, real-time strategy (RTS), multiplayer games in C++.

Addressing Fragmentation in ZGC through Custom Allocators

Wed, 19 Jun 2024 00:00:00 +0000

This is a repost of my blog entry about my master thesis at Oracle. The original was published on inside.java.

My name is Joel and I am currently finishing my 5-year degree in Computer and Information Engineering at Uppsala University, with a focus on Software Engineering. This blog post details my master thesis work as part of the GC team at Oracle’s Stockholm office in the spring of 2024. I’ve worked closely with Casper Norrbin and Niclas Gärds, who have also conducted their masters theses as Oracle this spring in the same area as I have. Problem Statement