George Ball on foojay.io - Friends of OpenJDK

Achieving High Throughput Without Sacrificing Latency

Fri, 02 Feb 2024 09:39:47 +0000

Latency and Throughput

In discussions on performance, it is common to encounter the terms Latency and Throughput to describe the characteristics of a software component.

We can define these terms as follows:

Latency is a measure of the time taken for one thing to occur. For example, it could be the time taken to respond to a change in the price of a financial instrument that could influence the decision on whether to buy, or sell. It could be the time taken for a component monitoring some external device to respond to an indication of a change in the status of that device (like a change in temperature reported from a thermometer).

Strategies for Managing State in Chronicle Services

Fri, 01 Dec 2023 08:41:44 +0000

Introduction

In distributed, microservice-based applications, the management of state is one of the most important, yet difficult aspects of design.

Ensuring the accuracy and consistency of state without introducing excessive complexity that affects performance or flexibility to support evolving requirements requires careful thought.

This article discusses issues around state management and shows how the Chronicle Services framework provides support to deal with these in ways that maintain a resilient and high performing microservices architecture.

Navigating Behaviour with Events

Wed, 25 Oct 2023 15:04:35 +0000

Two Approaches

There’s little doubt that modern software architectures lean towards asynchronous models for communication between distributed components (where “distributed” means components that are not part of the same process, be they on the same or on different physical machines). Synchronous models such as Remote Procedure Call (RPC) are now largely discredited [Waldo , Vinoski ]; even asynchronous variants of these are not seen as desirable.

When we strip away the layers that present the illusion that RPC is really just the same as Local Procedure Call (i.e. a normal method invocation), we find sitting above the transport some form of messaging protocol. And these days, the APIs seem more willing to expose developers to these lower-level details, making it clear to programmers that communication with a remote component is inherently more complex than making a simple procedure call.

Chronicle Services: Building Fast Microservices with Java

Wed, 13 Sep 2023 13:47:47 +0000

Low Latency?

In computing, latency is defined as the length of time to perform some task. This could be the time it takes to respond to an interrupt from hardware or the time it takes for a message sent by one component to be available to its recipient.

In many cases, latency is not seen as a primary non-functional concern when designing an application, even when considering performance. Most of the time, after all, computers seem to do their work at speeds that are well beyond human perception, typically using scales of milliseconds, microseconds, or even nanoseconds.

Billions of Messages Per Minute Over TCP/IP

Wed, 05 Jul 2023 21:05:08 +0000

Key Takeaways

Data consistency is critical when communicating between software components on different machines to ensure information remains in tact.
Low-latency data exchange requires a different approach than common formats.
Chronicle’s open-source Wire library provides a highly efficient means of marshalling and unmarshalling data for transmission to and from Chronicle Queue.
Recent additions to the library extend its use with TCP/IP communications channels, offering extremely high throughput.
Using Wire across TCP/IP opens up the possibility of Cloud Native deployment of Chronicle-based applications.

Introduction

One of the most important issues when building distributed applications is that of data representation. We must ensure that data sent by a component to a “remote” component (i.e. one that is part of a different process) is received correctly, with the same values. This may seem straightforward but remember that the communicating components may have been written in completely different languages.

Tuning Java Applications for Low Latency on Linux

Wed, 10 May 2023 13:34:13 +0000

Introduction

I have lost count of the number of times I have been told that Java is not a suitable language in which to develop applications where performance is a major consideration. My first response is usually to ask for clarification on what is actually meant by “performance” as two of the most common measures – throughput and latency, sometimes conflict with each other, and approaches to optimise for one may have a detrimental effect on the other.