Jerry Shea on foojay.io - Friends of OpenJDK

Monitoring Event Loops for Blockages

Mon, 15 May 2023 16:42:18 +0000

Chronicle’s open source Chronicle Threads library has a little known feature which is one of the first tools I get from my bag if a client reports that they are seeing latency outliers.

The usual way that a developer will measure their system for latency hotspots is to use a profiler, and modern profilers are amazing; there are numerous commercially available, but I generally find myself using Java Flight Recorder, async-profiler, or honest-profiler. These three are engineered to avoid the safepoint bias , and thus give very accurate results.

The Unix Philosophy for Low Latency

Thu, 04 May 2023 08:03:40 +0000

Unix has been around for more than 50 years, and the original design principles must be good enough for it (and its derivative, Linux) to be the most widely used Operating System on the planet – 80% of servers , most supercomputers , and the most deployed OS (Android ). It is also the most popular OS on Mars!

Much of Unix’s success can be attributed to the “Unix Philosophy ” which can be very briefly summarised as:

Chronicle FIX: Much More Than a Quick Fix

Wed, 12 Apr 2023 13:55:24 +0000

Many of our customers have upgraded from QuickFIX/J to Chronicle FIX and this article provides some background as to why.

Introduction

QuickFIX/J is free, accessible, supports the FIX standard and is therefore often chosen by the IT team for a first FIX engine.

However, when the business grows, its limitations become clear. The reasons most commonly given to us are:

Throughput and latency
HA/DR functionality
Advanced features e.g. routing and message translation
Global commercial support

Also, some customers engage with us because they already use our open source products e.g. Chronicle Queue, or our enterprise products e.g., Chronicle Queue Enterprise replication, or Chronicle Services EDA/Microservices accelerator.

Reducing Tail Latencies with Chronicle Queue Enterprise

Wed, 09 Nov 2022 15:07:36 +0000

Persistent queue solutions are frequently used when designing low-latency applications.

The problem is that high sustained message rates, or bursty workloads, can lead to delays caused by the OS or hardware which are challenging to mitigate.

In this article, we will describe how Chronicle Queue Enterprise solves this.

Background

When benchmarking Java low-latency persistent queue solutions, latencies tend to be excellent up to high percentiles until sustained throughput limits are reached; these sustained throughput limits are determined by disk performance, OS version, and configuration.