What is Chronicle Engine

Chronicle Engine is a high performance, low latency, access gateway library. It can be used to control and manage access to your data, your services across a cluster of machines. In microservices terms is an API Gateway.  It runs embedded as an existing system and as a container for the most performance critical part of your server application.

Chronicle Engine Provides

  • Managed thread pools for processing events.
  • Persisted and distributed Queues and Maps.
  • Clustered configuration.

Chronicle Engine can handle millions of events per second, with latencies around a micro-second on one machine and latencies below 25 micro-seconds across multiple machines.

Use Case:

Data Grid and Microservices API Gateway

Chronicle Engine can access your back end services with a minimum of overhead and provide monitoring and control over which data and services a client can access.

The benefits are:

  • Engine can tap into your services with a minimum of interruption, access the Queues and Map they use directly.
  • Abstraction of the underlying data storage supports changes in schema, and data storage solution.
  • Access control down to the key level for map, and topic level for queue.
  • Present a single view for a distributed micro-service architecture for monitoring and control purposes.

Use Case:

Database Cache for Reads and Writes

Chronicle Engine can access cached data at in memory speeds, while keeping a copy on disk.

The benefits are:

  • Take your database out of the critical path for reads and writes.
  • Persist writes locally and spooned to your database as fast as it allows.
  • Test your system independently of the state of a database, in a deterministic and reproducible manner.
  • Add in-Java triggers for changes.
  • Record all changes which can be replayed for testing purposes.

Use Case:

Share Data Between JVMs at Bare Metal Speed.

Chronicle Engine can share the same data between processes on the same machine with only one copy in memory.  Across machines it replicates the changes and reconciles the differences automatically.

The benefits are:

  • Read/Write speeds of less than 10 ns for data which changes rarely.
  • Read/Write speeds of less than 60 ns for data which changes often through zero copy data storage.
  • Access data between processes at the same speed as in process.
  • Use data which is persisted to the disk cache synchronously at the same speed as in memory.
  • Restart your caches in until 10 ms, even for hundreds of GB of data.

 

Chronicle-Engine_Shared-Data_simple_01

Use Case:

Monitor Existing Applications

Chronicle Engine can replace your existing logging and Map storage which not only speeds up these operations but makes them immediately available to other processes.

The benefits are:

  • Read/Write speeds of less than 10 ns for data which changes rarely.
  • Read/Write speeds of less than 60 ns for data which changes often through zero copy data storage.
  • Access data between processes at the same speed as in process.
  • Use data which is persisted to the disk cache synchronously at the same speed as in memory.
  • Restart your caches in until 10 ms, even for hundreds of GB of data.
Chronicle-Engine_Monitor-Existing_simple_01

Use Case:

Low Latency Event Driven System – Algorithmic Trading or Pricing System.

Chronicle Engine can manage the relationships between critical threads in your system. Being able to reply the precise inputs with original timings can allow you to have a highly deterministic system.

The benefits are:

  • Faithful reproduction of behaviour seen in production, to reproduce exotic errors and have confidence you have fixed them.
  • Low latency end to end solution. As low as 25 microseconds tick to trade.
  • Ultra low GC infrastructure allows you to run all day without a minor or major collection eliminating a key source of jitter.
 Chronicle-Engine_Low-Latency_simple_01

Use Case:

Client Graphical User Interfaces (GUIs) sharing larger, faster data sets.

Distributing fast data to many clients can put strain on your network, and high numbers of rows in tables, and high update rates can slow down your client.

The benefits are:

  • You can throttle the rate of updates sent over UDP/TCP so that while the server might be updating at rates of millions per second,  the client will receive the latest update, (  constrained by your network latency ).
  • Your clients can hold more data in a scalable way. All the data is stored off heap so has no impact on your garbage collector (GC) pause times.  This allows you to scroll around tables with millions of rows without GC pauses. Using off heap storage can reduce your heap requirement by 80%.

Chronicle-Engine_Scaleable-Client_simple_01

For More Information

Download Latest Versionsales@chronicle.software
GitHubSource Code
Source Code DocumentationJavaDoc
Stack OverflowQuestion