Revisit performance bottlenecks in hot code paths using Lettuce through the reactive Template

[vinsguru]

I was trying to run this simple performance test with Spring Data Redis vs lettuce.

Spring Data Redis seems to be significantly slow with default configuration compared to lettuce. (The throughput is 50% less with Spring Data Redis). Is this much difference expected?

You can check yourself wit this code.

Spring Boot : 2.5.2
spring-boot-starter-data-redis-reactive

   @RepeatedTest(3)
    public void springDataRedisPerformance(){
        ReactiveValueOperations<String, String> valueOperations = redisTemplate.opsForValue();
        long before = System.currentTimeMillis();
        Mono<Void> mono = Flux.range(1, 500_000)
                .flatMap(i -> valueOperations.increment("user:1"))
                .then();
        StepVerifier.create(mono)
                .verifyComplete();
        System.out.println((System.currentTimeMillis() - before) + " ms");
    }

    @RepeatedTest(3)
    public void lettucePerformance() throws InterruptedException {
        RedisClient redisClient = RedisClient.create("redis://localhost:6379/0");
        StatefulRedisConnection<String, String> connection = redisClient.connect();
        RedisReactiveCommands<String, String> reactiveCommands = connection.reactive();

        long before = System.currentTimeMillis();
        Mono<Void> mono = Flux.range(1, 500_000)
                .flatMap(i -> reactiveCommands.incr("user:1"))
                .then();

        StepVerifier.create(mono).verifyComplete();
        System.out.println((System.currentTimeMillis() - before)  + " ms");
    }

[mp911de]

There are some odd things in the code posted here.

First, creating a new RedisClient instance for each test run which is associated with creating thread pools each time that pollute your resources. Secondly, a. lot of additional load is put onto the code paths by using reactive API chaining. Finally, a proper benchmark consists of a warmup phase along with warmup iterations followed by multiple measurement iterations.

We're happy to review profiler findings if you can share some of these with us.

[vinsguru]

@mp911de

I create one RedisClient. then make 500_000 calls. This is the actual test. @RepeatedTest is ignoring the first run for warming up and consider subsequent runs. You can ignore RepeatedTest if it is confusing or make it as instance level variable. The point here is - the result is still same.

     Mono<Void> mono = Flux.range(1, 500_000)
                .flatMap(i -> reactiveCommands.incr("user:1"))
                .then();

I see better performance with Lettuce. Not with Spring Redis Template. Thats the question.

Feel free to close!

[mp911de]

I recorded a profiling session and there are a few areas that we can optimize. A benchmark reports about 30% of performance difference between plain Lettuce and Spring Data Redis usage (6443 ms vs. 4044 ms)

Spring Data Redis Profiling.snapshot.zip

[mp911de]

With a proper benchmark we get:

Benchmark                                                  Mode  Cnt       Score       Error  Units
ReactiveRedisTemplateBenchmark.clientOnly                 thrpt   10   21845,692 ±   828,334  ops/s
ReactiveRedisTemplateBenchmark.clientReactiveConcatMap    thrpt   10   30100,343 ±   975,742  ops/s
ReactiveRedisTemplateBenchmark.clientReactiveFlatMap      thrpt   10  115879,389 ± 13242,159  ops/s
ReactiveRedisTemplateBenchmark.templateReactiveConcatMap  thrpt   10   26251,948 ±  1976,017  ops/s
ReactiveRedisTemplateBenchmark.templateReactiveFlatMap    thrpt   10   83184,567 ±  6757,851  ops/s

Baseline -> Spring Data overhead concatMap ~ 14%, flatMap 38%