Me gusta usar nombres detallados en Redis, por ejemplo set-allBooksBelongToUser:$userId.
¿Está bien o eso afecta el rendimiento?
Me gusta usar nombres detallados en Redis, por ejemplo set-allBooksBelongToUser:$userId.
¿Está bien o eso afecta el rendimiento?
Respuestas:
La clave de la que estás hablando no es realmente tan larga.
La clave de ejemplo que da es para un conjunto, los métodos de búsqueda de conjunto son O (1). Las operaciones más complejas en un conjunto (SDIFF, SUNION, SINTER) son O (N). Lo más probable es que poblar sea $userIduna operación más costosa que usar una clave más larga.
Redis viene con una utilidad de referencia llamada redis-benchmark, si modifica la prueba "GET" en src / redis-benchmark.c para que la clave sea simplemente "foo", puede ejecutar la prueba de clave corta después de make install:
diff --git a/src/redis-benchmark.c b/src/redis-benchmark.c
--- a/src/redis-benchmark.c
+++ b/src/redis-benchmark.c
@@ -475,11 +475,11 @@
benchmark("MSET (10 keys)",cmd,len);
free(cmd);
- len = redisFormatCommand(&cmd,"SET foo:rand:000000000000 %s",data);
+ len = redisFormatCommand(&cmd,"SET foo %s",data);
benchmark("SET",cmd,len);
free(cmd);
- len = redisFormatCommand(&cmd,"GET foo:rand:000000000000");
+ len = redisFormatCommand(&cmd,"GET foo");
benchmark("GET",cmd,len);
free(cmd);
Aquí está la velocidad de prueba GET para 3 ejecuciones posteriores de la tecla corta "foo":
59880.24 requests per second
58139.53 requests per second
58479.53 requests per second
Aquí está la velocidad de prueba GET después de modificar la fuente nuevamente y cambiar la clave a "set-allBooksBelongToUser: 1234567890":
60240.96 requests per second
60606.06 requests per second
58479.53 requests per second
Cambiar la clave una vez más a "ipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumlorem: 1234567890" da esto:
58479.53 requests per second
58139.53 requests per second
56179.77 requests per second
Entonces, incluso las teclas realmente largas no tienen un gran impacto en la velocidad de redis. Y esto está en GET, una operación O (1). Las operaciones más complejas serían aún menos sensibles a esto.
Creo que tener claves que identifiquen claramente qué valores tienen en gran medida supera cualquier rendimiento de velocidad minúscula que obtendrías de las claves abreviadas.
Si desea llevar esto más allá, también hay un -r [keyspacelen]parámetro en la utilidad redis-benchmark que le permite crear claves aleatorias (siempre que tengan ': rand:' en ellas), simplemente puede aumentar el tamaño del prefijo en el prueba de código a la longitud que quisieras.
A Redis le gusta mantener todas las teclas en la memoria. Cuanto más larga sea la longitud promedio de la clave, menos se puede guardar en la memoria. Entonces, sí, la longitud de la clave puede afectar en gran medida el rendimiento, pero probablemente no de manera significativa en la forma en que le preocupa. Es decir, con un espacio de teclas pequeño (por ejemplo, uno que se adapta fácilmente a la memoria), una clave de 128 bytes y una clave de 16 bytes no funcionarán de manera dramáticamente diferente.
No puedo responder esta pregunta con certeza. Sin embargo, puedo hacer algunas preguntas al respecto y ofrecer algunas observaciones.
Creo que es obvio que las claves (nombres) y / o valores extremadamente largos tendrían un impacto en el rendimiento general si se pueden usar. Estos impactos podrían estar en el cliente, a través de la red o en el servidor. Entonces, la primera pregunta para sacar de la tuya sería:
¿Cuánto tiempo pueden durar las claves y los valores entre Redis y sus clientes?
Buscar en Redis , la longitud de la clave y los límites me proporciona una entrada de blog interesante en Redis vs. memcached que puede comenzar a responder a su pregunta. La primera respuesta a esa entrada en el blog parece haber sido escrita por Salvatore Sanfilipo, creador de Redis (principios del otoño pasado: 09/2010) sugiriendo que una versión más reciente mostraría resultados significativamente mejores. Dos comentarios desde ese enlace nos conectan con el Benchmark Redis / memcached de Salvatore, que se publicó unos días después de que respondiera al "blagger" original (que parece ser anónimo).
Esto no responde las preguntas (cuánto tiempo pueden durar las claves y en qué puntos hay impactos detectables en el rendimiento). Sin embargo, nos da una pista sobre cómo abordar la pregunta.
Los autores de estos dos artículos escribieron código y lo probaron ... y graficaron los resultados.
Podríamos hacer todo tipo de conjeturas. Podríamos mirar el código e intentar razonarlo.
Sin embargo, la forma más significativa de abordar una pregunta de este tipo es escribir un código para medir un patrón de uso propuesto ... y algo más para probar otro (por ejemplo, un rango de longitudes de clave que van desde 8 caracteres hasta ... cómo ¿Cuánto tiempo le gustaría ... 8 kilobytes?) ... y la medida.
No creo que la longitud del nombre de la variable afecte el rendimiento, la variable ocupará el mismo lugar que cualquier variable para ese tipo de datos, siempre que no exceda la longitud máxima del nombre.