load tests and number of concurrent connections

[loicdescotte]

Hi,

I'm trying to find the best way to use redis from a play framework application, to support a great number of connections and have a good request/second and response time ratio.

I made a few gatling tests : redisscala with async play features, redis-scala in blocking mode (with 'Await') and a bigger play thread pool, and finally Jedis/Sedis (synchronous and blocking).

My results are surprising : I reach the best scalability with the Jedis driver.
With Jedis I can easily reach 500 connected users (500 threads) but with redisscala if I use more than 100 threads to stress the app, it becomes very slow.

My code is very simple :

def asyncRedisQuery(q: String) = Action.async {
    val redis = RedisClient()
    redis.get(q).map(_.get).map(_.utf8String).map( result =>   
        Ok(result)
      )
  }

N.B : I've tried several execution context and thread pool configuration.

Did I miss something?

Thanks

[etaty]

Yep you should put val redis = RedisClient() outside of your main loop (here Action)

RedisClient() does a lot of thing (initialise a connection to redis server, pop 2 actors ...)

[loicdescotte]

Thanks for your reply, as the jedis client is not threadsafe, I put it at method level, and I did the same for your driver!
Trying now :)

[loicdescotte]

Now its works perfectly, and it's very fast!

My conclusions now are that the fastest test is redisscala with blocking code and a big thread pool (but the nb ofthreads will not be infinite...) , then the async redisscala, and then Jedis.

Thanks for your help!

[etaty]

Do you have numbers ?

Could you show the "redisscala with blocking code" ?

[loicdescotte]

Yep,

In fact I've relunched the load test and it's quite similar in blocking or not blocking mode (I hope it's readable on github) :

blockingredissimulation :

STATISTICS
Requests Executions Response Time (ms)
Total OK KO Min Max Mean Std Dev 95th pct 99th pct Req/s
Global Information 10000 10000 0 0 80 1 5 10 30 906
request_blocking_redis 10000 10000 0 0 80 1 5 10 30 906

async redissimulation :

STATISTICS
Requests Executions Response Time (ms)
Total OK KO Min Max Mean Std Dev 95th pct 99th pct Req/s
Global Information 10000 10000 0 0 120 2 6 10 30 929
request_redis 10000 10000 0 0 120 2 6 10 30 929

The blocking redis code is very simple :

def blockingRedisQuery(q: String) = Action { 
    val result = Await.result(redis.get(q), 10 seconds).map(_.utf8String).getOrElse("not found")
    Ok(result) 
  }

It uses the default thread pool with 500 threads

[etaty]

Thanks.
If you are going for async, you can reduce the thread pool size.

What was the number with Jedis?

[etaty]

Also you should avoid doing many map on a Future when you can write it in one map :

.map(_.get).map(_.utf8String).map( result =>   
        Ok(result)
      )

.map(r => Ok(r.get.utf8String))

Each time you map, you add a Future to threadpool which will have to be scheduled

[loicdescotte]

Thanks for the tip, I'll try like this
For the thread pools, I have 500 threads for Jedis and "blocking redisscala", but for the async redisscala test, I have only 1 thread by cpu

[loicdescotte]

I've removed the useless map operation
Now I have EXACTLY the same performance with async and blockign simulations : 997 request/sec and 84% of requests <= 1ms

I can put the benchmark on github if you wish

[etaty]

Yep good idea, it might help other.

[loicdescotte]

I've pushed everything here : https://github.com/loicdescotte/play-redis-benchmarks