Coordinated Restore at Checkpoint on CRaC

Spring Boot

Mon, 01 Jan 0001 00:00:00 +0000

Spring Boot provides CRaC support as of version 3.2, for more details see:

Examples:

Best practices

Mon, 01 Jan 0001 00:00:00 +0000

Best practices for implementing CRaC support in your application/library

This guide assumes you are already familiar with the concepts and Resource API; please check out the step-by-step guide for those.

Implementing Resource as inner class

In order to encapsulate the functionality, the Resource interface is sometimes not implemented directly by the component but we rather create an (anonymous) inner class. However it is not sufficient to pass this resource to the Context.register() method; Global Context tracks resources using weak references. As there is no unregister method on the Context, had a strong reference been used this would prevent the component from being garbage-collected when the application releases it. Therefore the class implementing Resource should be stored inside the component (in a field) to prevent garbage-collection:

Quarkus

Mon, 01 Jan 0001 00:00:00 +0000

Basic CRaC support is a part of Quarkus since 2.10.0 .

Example: https://github.com/CRaC/example-quarkus

What CRaC is

Mon, 01 Jan 0001 00:00:00 +0000

Coordinated Restore at Checkpoint (CRaC) is an OpenJDK feature that provides a fast start and immediate performance for Java applications.

A Java application and JVM are started from an image in a warmed-up form. The image is created from a running Java instance at arbitrary point of time (“checkpoint”). The start from the image (“restore”) continues from the point when checkpoint was made.

Measured results

Mon, 01 Jan 0001 00:00:00 +0000

CRaC support was implemented in a few frameworks with the following results. The source code can be found in the frameworks with CRaC support .

The environment

laptop with Intel i7-5500U, 16Gb RAM and SSD.
Linux kernel 5.7.4-arch1-1
data was collected in container running ubuntu:18.04 based image
host operating system: archlinux

jdk14-crac build

Checkpoint engines

Mon, 01 Jan 0001 00:00:00 +0000

CRaC’s API is deliberately mechanism-agnostic: it tells your application that a checkpoint is happening without saying how. The mechanism that actually takes the image is a separate choice, made with -XX:CRaCEngine=.

Runtimes with CRaC support

Mon, 01 Jan 0001 00:00:00 +0000

To use the CRaC functionality, you need a Java runtime that has support for CRaC integrated.

Runtimes differ in more than whether they have CRaC at all: the mechanism that takes the image is selectable, and which mechanisms a build offers is part of what you are choosing between. See checkpoint engines .

Debugging failures

Mon, 01 Jan 0001 00:00:00 +0000

Debugging checkpoint and restore failures

This guide will help you identify common problems when the checkpoint operation does not work.

Failures in native C/R

When the checkpoint operation fails in the native part, there is usually little information in the stack trace of the exception:

Implementing the CRaC API

Mon, 01 Jan 0001 00:00:00 +0000

WARNING: next is a proposal phase and is subject to change

Please refer to the frameworks with CRaC support , step-by-step guide or best practices guide to get an application with CRaC support. The rest of the section is written for the spring-boot example .

Jetty

Mon, 01 Jan 0001 00:00:00 +0000

Step-by-step CRaC support for a Jetty app

A program can be restored in a different environment compared to the one where it was checkpointed. Dependencies on the environment need to be detected and a coordination code need to be created to update the dependencies after restore. Such dependencies are open handles for operating system resources like files and sockets, cached hostname and environment, registration in remote services, …

Micronaut

Mon, 01 Jan 0001 00:00:00 +0000

You can just add crac feature at https://micronaut.io/launch !

Micronaut CRaC Module
- Hikari DataSources coordination
- Redis coordintation
Build System
- a single command to generate a docker image with CRaC image included

Example: https://github.com/CRaC/example-micronaut

Helidon

Mon, 01 Jan 0001 00:00:00 +0000

Helidon has shipped CRaC support since 4.2, as a preview feature — Helidon’s own documentation says the feature is subject to change and will be finalized in a later release, so treat the API below as not yet settled.

Quarkus Super Heroes

Mon, 01 Jan 0001 00:00:00 +0000

This guide will walk you through the process of taking an existing non-trivial application and getting it CRaC-able. The workshop describes the application, please refer there for any details. We’ll start right away with the result of that workshop:

AWS Lambda

Mon, 01 Jan 0001 00:00:00 +0000

AWS Libs with CRaC allows implementation of AWS Lambda functions on CRaC JDK.

Artifacts: https://mvnrepository.com/artifact/io.github.crac.com.amazonaws

Example: https://github.com/crac/example-lambda (diff ) is a sample Java serverless function on CRaC.

Changes: https://github.com/CRaC/aws-lambda-java-libs/compare/master...crac

Checkpoint and restore

Mon, 01 Jan 0001 00:00:00 +0000

WARNING: next is a proposal phase and is subject to change

Please refer to the frameworks with CRaC support , step-by-step guide or best practices guide to get an application with CRaC support. The rest of the section is written for the spring-boot example .

CPU features

Mon, 01 Jan 0001 00:00:00 +0000

CPU features differ from host to host as newer CPUs offer support for newer instructions, and some optional features may be removed over time. JVM (Java Virtual Machine) depends on CPU features (such as AVX512, SSE3 etc.) of each computer it is running on. The more CPU features JVM can use the better performance it can provide. JVM normally uses all the CPU features it can find on the CPU where it has started.

File descriptor policies

Mon, 01 Jan 0001 00:00:00 +0000

CRaC requires that the application closes all open files, network connections etc. - on Linux these are represented as file descriptors. However, it might be difficult to alter the application to properly coordinate with the checkpoint, e.g. due to a code in a library you cannot modify. In those cases CRaC offers a limited handling via configuration. Note that this applies only to file descriptors opened through JDK API; anything opened through native code cannot be handled this way.

Page not found

Mon, 01 Jan 0001 00:00:00 +0000

The likely destinations:

Using CRaC — the deployment scheme, runtimes, and taking a checkpoint
Implementing the API — coordinating your own resources
Frameworks — Spring Boot, Quarkus, Micronaut, AWS Lambda
Reference — best practices, debugging, file descriptors, CPU features
Sitemap — everything, on one page

If a link on this site brought you here, that is worth raising on the project’s repository .

Search

Mon, 01 Jan 0001 00:00:00 +0000

Sitemap

Mon, 01 Jan 0001 00:00:00 +0000