O comprimento do nome afeta o desempenho no Redis?

Eu gosto de usar nomes detalhados no Redis, por exemplo set-allBooksBelongToUser:$userId.

Isso está bom ou isso afeta o desempenho?

A chave que você está falando sobre o uso não é realmente tão longa.

A chave de exemplo que você fornece é para um conjunto, os métodos de pesquisa de conjunto são O (1). As operações mais complexas em um conjunto (SDIFF, SUNION, SINTER) são O (N). As chances são de que o preenchimento $userIdfoi uma operação mais cara do que o uso de uma chave mais longa.

O Redis vem com um utilitário de benchmark chamado redis-benchmark, se você modificar o teste "GET" em src / redis-benchmark.c para que a chave seja apenas "foo", você poderá executar o teste de chave curta depois 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);

Aqui está a velocidade do teste GET para três execuções subseqüentes da tecla curta "foo":

59880.24 requests per second
58139.53 requests per second
58479.53 requests per second

Aqui está a velocidade do teste GET após modificar a fonte novamente e alterar a chave para "set-allBooksBelongToUser: 1234567890":

60240.96 requests per second
60606.06 requests per second
58479.53 requests per second

Alterar a chave mais uma vez para "ipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumloreipsumlorem: 1234567890" dá a este:

58479.53 requests per second
58139.53 requests per second
56179.77 requests per second

Assim, mesmo chaves realmente muito longas não têm um grande impacto na velocidade dos redis. E isso é no GET, uma operação O (1). Operações mais complexas seriam ainda menos sensíveis a isso.

Eu acho que ter chaves que identifiquem claramente quais valores eles mantêm supera qualquer desempenho de velocidade minúsculo que você obteria com chaves abreviadas.

Se você quiser levar isso adiante, também há um -r [keyspacelen]parâmetro no utilitário redis-benchmark que permite criar chaves aleatórias (contanto que tenham ': rand:' nelas), você pode apenas aumentar o tamanho do prefixo no teste de código no tamanho que você desejar.

O Redis gosta de manter todas as teclas na memória. Quanto maior o tamanho médio da chave, menor será a memória. Portanto, sim, o comprimento da chave pode afetar significativamente o desempenho, mas provavelmente não significativamente na maneira como você está preocupado. Ou seja, com um pequeno espaço de chave (por exemplo, um que cabe facilmente na memória), uma chave de 128 bytes e uma chave de 16 bytes não terão um desempenho dramaticamente diferente.

Não posso responder a essa pergunta com certeza. No entanto, posso fazer algumas perguntas sobre o assunto e fazer algumas observações.

Eu acho que é óbvio que chaves (nomes) e / ou valores extremamente longos teriam um impacto no desempenho, se puderem ser usados. Esses impactos podem estar no cliente, na rede ou no servidor. Portanto, a primeira pergunta a ser tirada da sua seria:

Por quanto tempo as chaves e os valores podem estar entre a Redis e seus clientes?

Pesquisando em Redis , o tamanho e os limites das chaves , é uma interessante entrada de blog sobre Redis vs. memcached, que pode começar a responder sua pergunta. A primeira resposta a essa entrada do blog parece ter sido escrita por Salvatore Sanfilipo, criador do Redis (início do outono passado: 09/2010), sugerindo que uma versão mais recente mostraria resultados significativamente melhores. Dois comentários abaixo nos vinculam ao Redis / Memcached Benchmark de Salvatore, que foi publicado alguns dias depois que ele respondeu ao "blagger" original (que parece ser anônimo).

Isso não responde às perguntas (quanto tempo as chaves podem ter e em que pontos há impactos detectáveis ​​no desempenho). No entanto, ele nos dá uma pista sobre como abordar a questão.

Os autores de ambos os artigos escreveram código e o testaram ... e representaram graficamente os resultados.

Poderíamos fazer todos os tipos de suposições. Poderíamos olhar o código e tentar justificá-lo.

No entanto, a maneira mais significativa de abordar uma questão desse tipo é escrever um código para medir um padrão de uso proposto ... e mais para testar outro (por exemplo, um intervalo de comprimentos de chave que variam de 8 caracteres a ... como quanto tempo você gostaria ... 8 kilobytes?) ... e a medida.

Eu não acho que o tamanho do nome da variável afetará o desempenho, a variável ocupará o mesmo lugar que qualquer variável para esse tipo de dados, desde que você não exceda o tamanho máximo do nome.