Introduction

In the blog post How to create, publish and use layers for Java 21 Lambda functions we explained how to publish our first Lambda layer with Java 21. In the article Measuring cold and warm starts with Java 21 using Lambda layer (1) we created the application using this Lambda layer and then measured cold and warm start times without SnapStart enabled, with SnapStart enabled and also applied DynamoDB invocation priming optimization and compare the results with our measurements without using the Lambda layers and providing all dependencies in the POM file which we did in the article Measuring cold and warm starts with Java 21 using different Lambda memory settings. In this article we'll create another Lambda layer will all dependencies and use this layer in our application, make the same measurements and compare the result with the previous experiment.

Measuring cold and warm starts with Java 21 using Lambda layer with all dependencies

For the sake of exploration we'll use the sample Lambda layer for creating the Lambda layer with Java 21 runtime packaging the all dependencies into the layer :

• dynamodb
• lambda
• apache-client
• aws-lambda-java-core
• aws-lambda-java-events
• org-crac
• slf4j-simple
• jackson-dataformat-xml

We'll also use the sample application. There are basically 2 Lambda functions defined in the AWS SAM template which both respond to the API Gateway requests and retrieve product by id received from the API Gateway from DynamoDB. One Lambda function GetProductByIdWithPureJava21LambdaWithAllLayer can be used with and without SnapStart and the second one GetProductByIdWithPureJava21LambdaAndPrimingWithAllLayer uses SnapStart and DynamoDB request invocation priming.

In order to use the Lambda layer with all dependencies created previously for the Lambda functions in the AWS SAM template we have to add Layers parameter to the Lambda function like this:

    Type: AWS::Serverless::Function
    Properties:
      FunctionName: GetProductByIdWithPureJava21LambdaWithAllLayer
      AutoPublishAlias: liveVersion
      Layers:
        - !Sub arn:aws:lambda:${AWS::Region}:${AWS::AccountId}:layer:aws-pure-java-21-common-lambda-layer:1
      Handler: software.amazonaws.example.product.handler.GetProductByIdHandler::handleRequest

Please replace the Layer ARN (including the version) with your own which is the output if the publish layer command (aws lambda publish-layer-version).

In pom.xml you see all dependencies with the scope provided (by the Lambda layer attached).

The results of the experiment below were based on reproducing more than 100 cold and approximately 100.000 warm starts with experiment which ran for approximately 1 hour. For it (and experiments from my previous article) I used the load test tool hey, but you can use whatever tool you want, like Serverless-artillery or Postman.
I ran all these experiments by giving our Lambda functions 1024 MB memory and by passing the following compilation option via the environment variable: JAVA_TOOL_OPTIONS: "-XX:+TieredCompilation -XX:TieredStopAtLevel=1" (client compilation without profiling).

In the tables below I'll also provide the results with our measurements without using the Lambda layers (and providing all dependencies in the POM file) which we did in the article Measuring cold and warm starts with Java 21 using different Lambda memory settings and the measurements when using common Lambda layer to directly have the comparison.
Abbreviation c is for the cold start and w is for the warm start.

Cold (c) and warm (w) start times without SnapStart in ms:

Cold (c) and warm (w) start times with SnapStart without Priming in ms:

Cold (c) and warm (w) start times with SnapStart and with DynamoDB invocation Priming in ms:

Conclusion

In this article we created the application using the Lambda layer with all dependencies and then measured cold and warm start times without SnapStart enabled, with SnapStart enabled and also applied DynamoDB invocation priming optimization and compared the results with our measurements without using the Lambda layers (and providing all dependencies in the POM file) which we did in the article Measuring cold and warm starts with Java 21 using different Lambda memory settings and using common Lambda layer.

Even if I had some deviations in the results but the trend was always the same after multiple measurements using the Lambda layer with all dependencies:

• When not enabling SnapStart the cold start with this Lambda layer was up to several hundred milliseconds lower than without usage the Lambda layer for percentiles up to p90 (which surprised me).
• When enabling SnapStart but not using priming of the DynamoDB request the cold starts varied in favor of the Lambda layer with all dependencies or in favor of the Lambda which doesn’t use Lambda layers at all depending on the percentile.
• When using SnapStart with priming of the DynamoDB request the cold starts were close for both use cases for percentiles up to p99 and then higher for p99.9 and above when using the Lambda layer with all dependencies. So, the results varied a lot for each use case. What I always observed is that the result’s range was quite big (800-900ms difference between p50 and max values) for all measurements when using the Lambda layer with all dependencies and the same range was much lower when not using Lambda layers at all.
• When comparing the measurements in this article with measurements with common Lambda layer we observe we got lower cold starts for using all dependencies in the Lambda layers for the first 2 experiments (no SnapStart enabled and SnapStart enabled but no priming applied) and vice when SnapStart is enabled and DynamoDB invocation is primed.
• The warm starts/execution times of the Lambda function were quite close for all use cases.

So the usage of the Lambda layers (depending what you put there and what you ship as a dependency in your application) adds some unpredictability and you should always do your own measurements!