What does Chronicle Software do?

By

Overview

Chronicle Software is about simplifying fast data.  It is a suite of libraries to make it easier to write, monitor and tune data processing systems where performance and scalability are concerned.

But its free, how do you make money, through support?

We offer premium support. However, we often hear from users for the first time about a year after they have it in production.  Most users find they can support the software themselves.  It is only after a year or so, they have questions or concerns about where to take the product next.  In many cases, it is to a problem we have already solved and they just need to upgrade their software or use a new module we have added.

As we don't know who is using most of our software, we can't advise them on how best to use our software and what updates or enhancements they would benefit from. We need users to contact us and ask questions.  We have a free forum, and we respond to 50% of questions in 2 hours.

What we do know is we get downloads from over 1000 unique IP addresses each month and this is growing.

Is it from licenses?

Licenses for our Chronicle Enterprise module are an important part.  Our clients like how easy it is to customise our components. It's not a black box product.  The consulting, training and workshop services we can provide also have a significant appeal.

So how do you make your money? 

We make most of our money from bespoke development.  We built the open source components we use ourselves, but often our clients come from non-Java background.

Sorry? Your clients are not Java shops?

Most of our paying clients have been C++ or C# shops.  They have found hiring top developers, especially in C++ increasing difficult and want the option of hiring Java Developers. They feel Java would reduce their time to market for the projects they have planned, especially if much of the infrastructure has already been written.

They have high expectations in terms of what their software should do for them, but they don't have the in house expertise to do this in Java.  In the past this has prevented them from switching to Java.  

They want a product suite and a company they can help them go from a basic understanding of Java to Expert Java in an aggressively sort time frame, or it's not worth switching to Java.

So what about the Free Software? What can I use it for?

I came across this web page today. Andreas Kull's Awesome Java We get a couple of mentions and I liked the way he broke down the categories so here is what Chronicle does in these areas.

Chronicle Engine

Chronicle Engine supports; Configuration, Distributed Applications, Messaging, Serialization, Reactive programming.

- Publish/Subscribe and Key-Value store.
- It supports building and wiring of objects with a simple configuration.
- Remote access to those components for Java and C#.
- Remote access via mounting as an NFS file system as simple, natrual way to access and manage your data.
- Real time updates to live queries via a streams like API using lambdas.
- Write lambdas on the client to be executed on the server atomically or asynchronously, for any purpose.
- Supports clustered applications.
- Support for millions of distributed actors per server.

Chronicle Wire

Chronicle Wire conflates; Configuration, Data Structures, JSON Processing, and Serialization.

It provides
  • Typed configuration you can save, and send across a network.  Here is an example from our demo.
  • supports both serialization and binding to off heap and byte[] data. It also has thread safe operations such as CAS and addAndGet to shared memory. It's designed to be very easy to understand exactly what it is doing and debug the code.
  • low latency JSON parser especially useful if you are concerned about minimising garbage.
  • high level serialisation library which supports serialization to YAML and a binary form.  Chronicle Bytes has a ultra low latency serialization which supports serialization and deserialization of a 6 field object with a String and an Enum in 210 nano-seconds.
  • a simple consistent interface across a variety of use cases.

Chronicle Queue

Chronicle Queue supports; Distributed Applications, Low latency Messaging, Logging and Replay.
  • High throughput (millions per second).
  • Low latency (micro-second) messaging, for ultra low GC applications*
  • Very fast replay for fast restarts and testing. A number of clients have said they really like the ability to recreate the state of the system at any point to debug rare bugs and be able to prove the problem has been fixed.
We have a client who is processing peaks of 24 million persisted messages per second.  

Small persisted messages typically pass between JVMs on the same machine in one micro-seconds and between machines in 8 micro-seconds. 
Note: we include the cost of serialization and deserialization in our timings, most messaging solutions do not.

The Reactor framework supports using Chronicle for it's persistence.

* Ultra low GC means less than one minor collection per day.

Chronicle Map

Chronicle Map supports; Distributed Applications, key-value Data Stores

An off heap shared, persisted, replicated ConcurrentHashMap.
- only one copy in memory for multiple JVMs. Changes in one JVM are available to another JVM within 50 nano-seconds. Locking between JVMs.
- replicated between machines in a cluster
- remote access

Chronicle Map supports large data sets in each server. One user is storing 10 TB of data in a single ConcurrentMap.

Chronicle Bytes

Chronicle Bytes supports efficient Native 64-bit thread safe access.

The library gives access to raw off heap memory and memory mapped files with 64-bit sizes. It supports thread safe operations such as locks across shared memory and bounds checking to avoid JVM crashes.

This can help maximise efficiency of exchanging data with native memory by using the intrinsics in the JVM.

Koloboke

This library contains high performance primitive and object Set and Map collections.  It uses code generation to pre build the collections you need. It is highly configurable to suit your requirements.



What about the Licensed software?

Chronicle Enterprise

Chronicle Enterprise is built on Chronicle Engine and extends it's features
  • Transparent data compression between 10:1 and 100:1 compression ratios reduce network consumption, improve scalability and memory usage.
  • Authorization and authentication of clients.
  • Monitoring of clients usage.
  • C# client with an Excel plugin which supports pub/sub and key-value access.
  • Client side caching of data.
  • Traffic shaping but number of messages or bandwidth used for clients and replication.
  • Multi-Cluster Wan replication support.
  • More features to come.

Chronicle Fix

Ultra low latency FIX engine.
  • Parse, generate and persist FIX messaging.
  • End to end latency of less than 7 micro-seconds 99.99% of the time to parse a NewOrderSingle, persist it, generate an ExecutionReport, write it to a SocketChannel and persist that. (Latencies on the server side)
  • Integrates with Chronicle Engine.
The Yellow line shows the total latency, not the higher percentiles are show in more details.  E.g. 99.9% latency is the worst 0.1% latency.


You have Questions?

If you have any questions about our consulting, support, bespoke development or licensed products please contact sales@chronicle.software.




Comments

Post a Comment

Popular posts from this blog

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

By
Image
  You still have to watch how many objects you create. 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 still avoid object allocations..  One of the key optimisations is creating almost no garbage. Allocation is a very cheap operation and collection of very short-lived objects is also very cheap. Does this really make 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? While allocation is as efficient as possible, it doesn’t avoid the memory pressure on the L1/L2 caches of your CPUs and when many cores are busy, they are contending for memory in the shared L3 cache.  Results Benchmark on a Ryzen 5950X with Ubuntu 22.10. JVM Vendor, Version No objects Throughput, Average Latency* One object per event Throughput, Average Latency* Azul Zulu 1.8.0_322 60.6 M event/s, 528
Read more

System wide unique nanosecond timestamps

By
A Unique Identifier can be very useful for tracing. Those ids are even more useful when they contain a high-resolution timestamp.  Not only do they record the time of an event, but if unique can help trace events as they pass through the system. Such unique timestamps however can be expensive depending on how they are implemented.   This post explores a lightweight means of producing a unique, monotonically increasing system-wide nano-second resolution timestamp available in our open-source library. Uses for Unique Identifiers Unique identifiers can be useful to associate with a piece of information so that information can be referred to later unambiguously. This could be an event, a request, an order id, or a customer id. They can naturally be used as a primary key in a database or key/value store to retrieve that information later. One of the challenges of generating these identifiers is avoiding creating duplicates while not having an increasing cost.  You could record every identi
Read more

Comparing Approaches to Durability in Low Latency Messaging Queues

By
Image
  A significant feature of Chronicle Queue Enterprise is support for TCP replication across multiple servers to ensure the high availability of application infrastructure. I generally believe that replicating data to a secondary system is faster than syncing 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. Little’s Law and Why Latency Matters In many cases, the assumption is that the latency won't be a problem as long as throughput is high enough. However, latency is often a key factor in why the throughput isn’t high enough. Little’s law states, “ the long-term average number  L  of customers in a  stationary  system is equal to the long-term average effective arrival rate  λ  multiplied by the average time  W  that a customer spends in the system”. In computer terminology, the level of concurrency or parallelism a system has to support must be
Read more