In che modo i client Redis implementano il pipelining?

Question

Negli Redis protocol documentation si afferma:

Un client può utilizzare la stessa connessione al fine di emettere più comandi. Il pipelining è supportato in modo che più comandi possano essere inviati con una singola operazione di scrittura da parte del client, non è necessario leggere la risposta del server per emettere il comando successivo. Tutte le risposte possono essere lette alla fine.

Tuttavia, non riesco a trovare alcun esempio di come questo sia effettivamente implementato. In che modo un client Redis implementa il pipelining?

Answer 1

Fintantoché è possibile delimitare facilmente i messaggi su uno stream TCP, per supportare un pipelining è necessario poco supporto, lo stack TCP memorizzerà i dati per il buffer e come server è possibile solo leggere/analizzare le richieste uno alla volta e rispedisci le risposte al termine delle richieste. Il client/server deve solo essere consapevole e gestire i casi quando questi buffer si riempiono, in modo da non deadlock.

Detto questo, per i redis dare un'occhiata a processInputBuffer()/processMultibulkBuffer() in networking.c, redis ha anche il proprio buffer di output, si veda ad es. addReply()

Answer 2

Un paio di buoni, semplici esempi di come questo è implementato può essere trovato nella fonte per il client Redis Ruby, redis-rb, e uno di Python, redis-py, rispettivamente elencati di seguito.

Fanno essenzialmente ciò che TaylorOtwell di cui sopra, concatenare lato client le richieste che saranno fatte a Redis in un oleodotto in una singola richiesta di rete, mentre le operazioni avrebbero utilizzare i comandi Redis MULTI/EXEC per iniziare e terminare una transazione.

Redis-RB (da redis.rb e pipeline.rb):

def pipelined(options = {}) 
    synchronize do 
    begin 
     original, @client = @client, Pipeline.new 
     yield 
     if @client.commands.empty? 
     [] 
     else 
     original.call_pipelined(@client.commands, options) 
     end 
    ensure 
     @client = original 
    end 
    end 
end 

def call_pipelined(commands, options = {}) 
    @commands.concat commands 
    nil 
end 

Un altro buon esempio in cui si trovano la fonte per redis-py, un client redis pitone. Spero possa aiutare.

Answer 3

Semplicemente aggiungendo alcune risposte alle risposte precedenti. Un modo per comprendere la pipeline redis è capire che la pipeline redis è completamente un'implementazione lato client e il server redis non ha nulla a che fare con esso. Mentre questo differisce tra le diverse implementazioni client, ecco l'idea generalizzata:

Il pipelining è finalizzato a risolvere i problemi di latenza di risposta in ambienti con latenza di rete elevata. Quindi, minore è il tempo trascorso sulla rete nell'invio di comandi e nella lettura della risposta, meglio è. Ciò è effettivamente ottenuto mediante il buffering. Il client può (o non può) bufferizzare i comandi nello stack TCP (come menzionato in altre risposte) prima che vengano inviati al server. Una volta inviati al server, il server li esegue e li memorizza sul lato server. Diversamente dal solito caso in cui il client legge la risposta non appena viene ricevuta la risposta, in caso di pipelining, il client legge le risposte dal buffer lato server in parti o quando l'applicazione esegue 'sync' (chiude la pipeline). Questo è vantaggioso perché il tempo trascorso sulla rete dal client nella lettura delle risposte è molto minore.

Ecco un post sul mio blog, che si può fare riferimento per avere una migliore idea: http://nachivpn.blogspot.in/2014/11/redis-pipeline-explained.html