Why is there a growing time delay when querying relatively large strings from redis using ioredis?

Question

Using ioredis in node, I am getting a value from redis that is around 100kb a significant amount of times (due to usage, in production). What im seeing is that every subsequent get takes slightly longer than the previous get.

I am trying to understand what the cause of this is, so that I can make a decision on how to tackle the problem.

I have a script to replicate what im seeing at the bottom. Results for getting the value 200 times look as follows:

0: time: 43ms
1: time: 45ms
2: time: 50ms
...
199: time: 234ms

You can see it go to 6x in just 200 gets. I even find the first latency surprisingly long, 43ms, I am running the script on the redis host, so no latency.

Script (need to update redis connection details of course):

import Redis from "ioredis";

const con = await new Redis({
  port: 6379,
  host: "somehost",
  family: 4,
  password:
    "somepassword",
  db: 5,
});

con.on("ready", function () {
  console.log("REDIS is ready for action");
});

// sleep for 1 sec to be sure redis is ready for action
await new Promise((resolve) => setTimeout(resolve, 1000));

// store a 100k value in redis
const key = "some:test:key";
const value = "a".repeat(100000);
await con.set(key, value);

// get the value asynchronously 200 times, log the time it took
for (let i = 0; i < 200; i++) {
  let t1 = Date.now();
  con.get(key).then((value) => {
    let t2 = Date.now();
    console.log(`${i}: time: ${t2 - t1}ms`);
  });
}

Answer 1

I think this is because of the Promises in your loop and the fact that JavaScript is single-threaded.

You're not actually calling Redis once, logging the response once, and then repeating this 200 times. Instead, you are queueing up 200 calls to Redis and then logging when they return. And since JavaScript is single-threaded, it can only return one of these at a time.

Looking at your log, it looks like the first call takes a bit of time—which seems reasonable—but then subsequent calls are taking a couple of milliseconds.

You could confirm that this isn't Redis by using the Redis benchmark tool. I did this with a 14 megabyte image file with Redis running on my local machine and got the following results:

$ redis-cli -x set test-key < really-big-image.png 
OK

$ redis-benchmark -n 200 -q script load "redis.call('get','test-key')"
script load redis.call('get','test-key'): 12500.00 requests per second, p50=1.303 msec  

It returned immediately with no perceivable lag.