A first look at the JIT

Tuesday, 3 November 2020 - John Högberg

Now that we've had a look at BEAM and the interpreter we're going to explore one of the most exciting additions in OTP 24: the just-in-time compiler, or "JIT" for short.

A closer look at the interpreter

Tuesday, 27 October 2020 - John Högberg

In my previous post we had a look at BEAM, and now that we're more familiar with it it's time for us to look at the reference implementation: the interpreter.

A brief introduction to BEAM

Tuesday, 20 October 2020 - John Högberg

This post is a brief primer on BEAM, the virtual machine that executes user code in the Erlang Runtime System (ERTS). It's intended to help those new to BEAM follow an upcoming series of posts about the JIT in OTP 24, leaving implementation details for later.

The New Scalable ETS ordered_set

Wednesday, 19 August 2020 - Kjell Winblad

The scalability of ETS tables of type ordered_set with the write_concurrency option is substantially better in Erlang/OTP 22 than earlier releases. In some extreme cases, you can expect more than 100 times better throughput in Erlang/OTP 22 compared to Erlang/OTP 21. The cause of this improvement is a new data structure called the contention adapting search tree (CA tree for short). This blog post will give you insights into how the CA tree works and show you benchmark results comparing the performance of ETS ordered_set tables in OTP 21 and OTP 22.

OTP 23 Highlights

Wednesday, 13 May 2020 - Kenneth Lundin

OTP 23 has just been released (May 13:th 2020). It has been a long process with three release candidates in February, March and April before the final release. We are very thankful for the feedback we have got regarding the release candidates, which has revealed some bugs and flaws that our internal testing did not find.

Clever use of persistent_term

Monday, 9 September 2019 - Lukas Larsson

This blog post will go through three different uses of persistent_term that I have used since its release and explain a bit why they work so well with persistent_term.

OTP 22 Highlights

Monday, 13 May 2019 - Lukas Larsson

OTP 22 has just been released. It has been a long process with three release candidates before the final release. We decided this year to try to get one month more testing of the major release and I think that the extra time has paid off. We've received many bug reports from the community about large and small bugs that our internal tests did not find.

ETS oddity

Monday, 7 January 2019 - Lukas Larsson

When working with the implementation of the new scalable ordered_set we came across a strangeness with the guarantees when iterating over a table while inserting elements in parallel.

Retiring old performance pitfalls

Wednesday, 7 November 2018 - John Högberg

Erlang/OTP 22 will bring many performance improvements to the table, but most of them have a broad impact and don't affect the way you write efficient code. In this post I'd like to highlight a few things that used to be surprisingly slow but no longer need to be avoided.

TLS logging improvements in OTP 22

Friday, 5 October 2018 - Péter Dimitrov

Erlang/OTP 22 will be an important release for the ssl application. We are working on several new features and improvements such as support for TLS 1.3, some of those are already on the master branch. This blog post presents the new ssl debug logging built on the new logger API.

SSA History

Friday, 28 September 2018 - Björn Gustavsson

This blog post looks back on the development of the SSA-based intermediate representation from the beginning of this year to the end of August when the branch was merged.

Digging deeper in SSA

Thursday, 20 September 2018 - Björn Gustavsson

This blog post continues the exploration of the new SSA-based intermediate representation through multiple examples. Make sure to read the Introduction to SSA if you missed it.

Introduction to SSA

Wednesday, 5 September 2018 - Björn Gustavsson

This blog post is an introduction to the new SSA-based intermediate representation that has recently been merged to the master branch in the Erlang/OTP repository. It uses the same example as in the previous blog post, first looking at the generated SSA code, and then at some optimizations.

Optimization Traps and Pitfalls

Friday, 24 August 2018 - Björn Gustavsson

Back after the summer holidays, this blog will now change tracks and start a series of blog posts about Static Single Assignment (SSA). This first installment will set the scene for the posts that follow by looking at the traps and pitfalls one can fall into when trying to optimize BEAM assembly code.

A Brief History of the BEAM Compiler

Monday, 18 June 2018 - Björn Gustavsson

This blog post is a brief history lesson about the Erlang compiler for the BEAM machine. To provide some context, there will first be a quick look at the abstract machines for Erlang.

Interpreter optimization

Monday, 11 June 2018 - Lukas Larsson

The BEAM interpreter in erts has been completely re-written in OTP 21. Most of the instructions have remained the same, but the perl scripts used to generate the C code have a new implementation. This blog post will look at some of the optimizations that were possible because of those changes.

Core Erlang Wrap Up

Wednesday, 30 May 2018 - Björn Gustavsson

This blog post wraps up the exploration of Core Erlang started in the previous two blog posts. The remaining default Core Erlang passes are described, followed by a look at how Core Erlang is represented internally in the compiler.

Core Erlang Optimizations

Friday, 18 May 2018 - Björn Gustavsson

This blog post continues the exploration of Core Erlang by looking at some optimizations done by the sys_core_fold compiler pass. The Core Erlang language was introduced in the previous blog post.

Core Erlang by Example

Monday, 7 May 2018 - Björn Gustavsson

This blog post is the first about the Core Erlang format. In this blog post, we introduce the Core Erlang format through examples that compare Erlang code to the corresponding Core Erlang code.

Memory instrumentation in OTP 21

Wednesday, 2 May 2018 - John Högberg

The memory instrumentation module was rewritten for Erlang/OTP 21 to make it easier to use. In this post I'll describe the rationale behind the new features and how to make use of them.

My OTP 21 Highlights

Wednesday, 2 May 2018 - Lukas Larsson

OTP-21 Release Candidate 1 has just been released. I thought that I would go through the changes that I am the most excited about. Most likely this will mostly mean features in erts and the core libraries as those are the changes that I am the most familiar with.

Lost in Translation (Exploring the Compiler's Front End)

Thursday, 26 April 2018 - Björn Gustavsson

In this blog post, we will explore the compiler passes that make up the compiler's front end.

Exploring the Compiler Using the 'time' Option

Thursday, 19 April 2018 - Björn Gustavsson

This is the first of a series of blog posts about the compiler. There will be blog posts about how the compiler works now, how it might work in the future, and some historical notes to explain why some things are what they are. In this blog post I will talk about one of the most useful options for exploring the compiler, namely the time option.

I/O polling options in OTP 21

Wednesday, 11 April 2018 - Lukas Larsson

Erlang/OTP 21 will introduce a completely new IO polling implementation. This new implementation comes with a new set of tuneable parameters that can be used to get the most out of your system. This blog post describes the parameters and attempts to describe what they should be used for.