Pipeline and Batch Execution

Reduce round-trip network latency by grouping multiple commands into a single transmission.

In this lesson, you will learn how to drastically improve performance by bundling multiple database operations into a single network transmission to eliminate redundant round-trip latency.

The Round-Trip Problem

When your application interacts with a remote cache or database, every individual command incurs a "round-trip time" (RTT). If you need to set 100 keys, your application sends a request, waits for the server to process it, and receives an acknowledgement—100 times over. Even if the network latency is just 1 millisecond, 100 sequential requests will take at least 100 milliseconds. This overhead often dwarfs the actual time the server spends executing the commands.

The Pipeline Solution

Pipeline execution solves this by allowing your client to send a stream of commands to the server without waiting for the individual replies of previous commands. The client pushes a large buffer of instructions into the network socket, and the server processes them sequentially, queueing the responses to be sent back in a single batch.

Imagine you are at a grocery store checkout. Instead of handing the cashier one item, waiting for them to scan it, paying, and walking away 100 times, you place all 100 items on the belt at once. The cashier processes them rapidly, and you finalize the transaction in one go.

Illustrative Example

Without pipelining, your application logic looks like this:

# Sequential: High latency due to many RTTs
for key, value in data_items:
    db.set(key, value) # 100 separate network trips

With pipelining, you group the commands:

# Pipelined: Low latency due to single network trip
with db.pipeline() as pipe:
    for key, value in data_items:
        pipe.set(key, value) # Buffering commands locally
    pipe.execute()           # One network trip sends all commands

By batching these commands, you transform 100 network round-trips into a single "bulk" transmission. The database server spends its time doing what it does best—executing logic—rather than sitting idle while waiting for the next packet to arrive from your application.

Key Takeaway: Pipelining reduces network overhead by grouping multiple commands into a single transmission, effectively hiding the cost of round-trip latency.