Peter Lawrey on foojay.io - Friends of OpenJDK

The IKEA Effect

Wed, 26 Jul 2023 13:00:04 +0000

The IKEA effect is a fascinating phenomenon whereby consumers place a (sometimes disproportionately) higher value on things that they have either made themselves, or to which they’ve contributed towards making.

This can have a significant influence on perceived value – to the extent that people might value imperfect things they’ve helped create, more than they would value the equivalent, perfect, but ready-made, product. Those who have pained memories of tussling with Allan keys and occasionally incomprehensible schematics for self-assembly furniture will no doubt have raised eyebrows. Of course, the effect only applies to items that are successfully assembled, of course. If people fail to build an item using the instructions provided, or it takes too long or is too difficult, due either to the complexity of the instructions or the inexperience of the user, then they do not ascribe the same value to the item.

Optimise CPU Performance Through Isolation and System Tuning

Thu, 29 Jun 2023 06:36:39 +0000

What are the challenges of tuning your CPU and system for optimal performance with Linux, and how does Chronicle Tune address them?

CPU isolation and efficient system management are critical for any application which requires low-latency and high-performance computing. These measures are especially important for high-frequency trading systems, where split-second decisions on buying and selling stocks must be made.

To achieve this level of performance, such systems require dedicated CPU cores that are free from interruptions by other processes, together with wider system tuning.

Unique Identifiers Based on Timestamps in Distributed Applications

Wed, 14 Jun 2023 11:22:03 +0000

At Chronicle we build applications that must process very high numbers of events with minimum latency. Generating unique IDs for these events using the traditional method of UUIDs introduces an unacceptable time overhead into our applications, so an alternative approach is needed.

I recently wrote an article on how timestamps can be used as unique identifiers, as they are much cheaper to generate than other methods of generating unique identifiers, taking a fraction of a microsecond.

Java is Very Fast, If You Don’t Create Many Objects

Thu, 01 Jun 2023 04:45:56 +0000

This article looks at a benchmark passing events over TCP/IP at 4 billion events per minute using the net.openhft.chronicle.wire.channel package in Chronicle Wire and why we aim to avoid object allocations.

One of the key optimisations is creating almost no garbage. Allocation is supposed to be a very cheap operation and garbage collection of very short lived objects is also very cheap.

Does not allocating really make such a difference? What difference does one small object per event (44 bytes) make to the performance in a throughput test where GC pauses are amortised?

Using Pausers in Event Loops

Wed, 17 May 2023 09:25:23 +0000

Typically in low-latency development, a trade-off must be made between minimising latency and avoiding excessive CPU utilisation.

This article explores how Chronicle’s Pausers can be used to automatically apply a back-off strategy when there is no data to be processed, providing an excellent balance between resource usage and responsive, low-latency, low-jitter applications.

Description of the Problem

In a typical application stack multiple threads are used for servicing events, processing data, pipelining etc.

Approaches to Durability in Low Latency Messaging Queues

Wed, 26 Apr 2023 13:17:59 +0000

A significant feature of Chronicle Queue Enterprise is support for TCP replication across multiple servers to ensure high availability of application infrastructure.

I have generally held the view that replicating data to a secondary system is faster than sync-ing to disk, assuming the round trip network delay wasn’t high due to quality networks and co-located redundant servers.

This is the first time I have benchmarked it with a realistic example.

Event-Driven Order Processing Program

Thu, 23 Mar 2023 09:27:37 +0000

Following the Hello World example of a simple, independently deployable real-time Event-Driven Microservice, this article looks at a more realistic example of an Order Processor with a New Order Single in and an Execution Report out.

A New Order Single is a standard message type for the order of one asset in the FIX protocol used widely by financial institutions such as banks.

The reply is typically one or more Execution Reports updating the status of that order.

Efficient Memory Mapping for Terabyte Sparse Files in Java

Wed, 15 Mar 2023 11:50:41 +0000

On Linux, you can create sparse files , where only the pages (of 4 KiB) that are touched utilise either memory or disk space.

This allows you to memory map large virtual regions without worrying about wasted memory or disk

In this program, you can see it reserves 8 TiB (8,192 GiB)

Figure 1. Test 1: Sparse file

Tip: x << y means x × 2y therefore:

1L << 10 = 1 KiB (1024 bytes),
1L << 20 = 1 MiB (10242 bytes),
1L << 30 = 1 GiB (10243 bytes),
1L << 40 = 1 TiB etc

Using multiples of 10 for the shift makes them easier to read.

Event Driven Hello World Program

Thu, 02 Mar 2023 16:34:35 +0000

Event-driven microservices can be straightforward to describe before they are implemented, tested and maintained.

They are also highly responsive to new information in real time, with latencies in Java of below 10 microseconds 99.99% of the time depending on the functionality of the small independently deployable microservice.

In this introductory article, we use an example event-driven Hello World program (a programming paradigm where the program flow is determined by events) to step through behaviour-driven development , where we describe the behaviour the business needs first as test data, and writing a very simple microservice which turns input events like this:

Behaviour Driven Development with Event Driven Architectures

Wed, 15 Feb 2023 07:57:18 +0000

Behaviour Driven Development (BDD) and Event Driven Architecture (EDA) work well together as they complement each other’s strengths and weaknesses.

Using both can result in a shorter time to market for new functionality and a more maintainable system.

Behaviour Driven Development (BDD) encourages a common language between users and developers in describing requirements in a form the users can understand but can also automatically be checked as the application is developed and maintained.

"The More You Say, the Less People Remember...

Wed, 25 Jan 2023 07:56:39 +0000

…The Fewer the Words, the Greater the Profit."

These wise words were written by François Fénelon, a writer and theologian living during the 17th century.

This is an article summarising different approaches to the development of IT solutions. Learn why the above quote is very relevant for developers in the 21st century.

Business Driven Development

Business-driven development is a meta-methodology for developing IT solutions that directly satisfy business requirements . This leads to increased flexibility and shorter turnaround times when changing the business and adapting the IT systems.

How Does Kafka Perform When You Need Low Latency?

Wed, 18 Jan 2023 10:12:24 +0000

Most Apache Kafka benchmarks appear to test high throughput but not low latency.

Kafka was traditionally used for high throughput rather than latency-sensitive messaging, but it does have a low-latency configuration. (Mostly setting linger.ms=0 and reducing buffer sizes).

In this configuration, you can get below 1-millisecond latency a good percentage of the time for modest throughputs.

Benchmarks tend to focus on clustering Kafka, in a high-throughput configuration.

While this is perhaps the most common use case, how does it perform if you need lower latencies?

Kafka vs. Chronicle for Microservices: Which is 750 Times Faster?

Wed, 30 Nov 2022 08:15:40 +0000

Apache Kafka is a common choice for inter-service communication.

Kafka facilitates the parallel processing of messages and is a good choice for log aggregation. Kafka claims to be low latency, high throughput . However, is Kafka fast enough for many microservices applications in the cloud?

When I wrote Open Source Chronicle Queue , my aim was to develop a messaging framework with microsecond latencies, and banks around the world have adopted it for use in their latency-sensitive trading systems and real-time streaming applications.

Unusual Java: StackTrace Extends Throwable

Wed, 23 Nov 2022 12:37:13 +0000

There are things you can do in Java you rarely see, generally because there is no use for it.

However, there are some unusual things in Java that could be surprisingly useful.

Chronicle Software uses a number of different useful patterns in its low-level libraries most developers wouldn’t generally come across.

One of them is a class that extends Throwable but isn’t an Error or an Exception.

StackTrace Extends Throwable

package net.openhft.chronicle.core;
/**
* Throwable created purely for the purposes of reporting a stack trace.
* This is not an Error or an Exception and is not expected to be thrown or caught.
*/
public class StackTrace extends Throwable {
 public StackTrace() { this("stack trace"); }
 public StackTrace(String message) { this(message, null); }
 public StackTrace(String message, Throwable cause) {
 super(message + " on " + Thread.currentThread().getName(), cause);
 }

 public static StackTrace forThread(Thread t) {
 if (t == null) return null;
 StackTrace st = new StackTrace(t.toString());
 StackTraceElement[] stackTrace = t.getStackTrace();
 int start = 0;
 if (stackTrace.length > 2) {
 if (stackTrace[0].isNativeMethod()) {
 start++;
 }
 }
 if (start > 0) {
 StackTraceElement[] ste2 = new StackTraceElement[stackTrace.length - start];
 System.arraycopy(stackTrace, start, ste2, 0, ste2.length);
 stackTrace = ste2;
 }

 st.setStackTrace(stackTrace);
 return st;
 }
}

Some important side notes to get out of the way first

Low Latency Microservices, A Retrospective

Thu, 06 Oct 2022 06:25:56 +0000

I wrote an article on low latency microservices almost five years ago now. Chronicle Software has worked with a number of tier one investment banks to implement and support those systems. What has changed in that time and what lessons have we learnt?

Read this article and learn what we learned after five years of developing and supporting low latency microservices.

Separation of Concerns Gives Better Testability

Microservices repeatedly demonstrated that testing and debugging business components were much easier with simple, stand-alone components with clear contracts between microservices.

Storing 1TB in Virtual Memory on a 128GB Machine

Tue, 27 Sep 2022 09:10:43 +0000

If you use a standard JVM like the Oracle JVM or the OpenJDK, you might find that as the heap size grows the performance of your JVM can drop as GC pause time escalates.

This tends to be a problem around 32 GB of heap, but it often depends on the application at which point the size of your heap becomes a problem.

One way around this is to use an always concurrent collector such as Azul Platform Prime which is designed to both scale to much larger heap sizes and even reduces the GC pause times for smaller heap consistently.