Load Options

This is a walkthrough of different load options available to control the rate in requests per second (RPS) that ghz attempts to make to the server. All examples are done using a simple unary gRPC call.

Constant RPS

  1. ghz --insecure --async \
  2.   --proto /protos/helloworld.proto \
  3.   --call helloworld.Greeter/SayHello \
  4.   -c 10 -n 10000 --rps 200 \
  5.   -d '{"name":"{{.WorkerID}}"}' 0.0.0.0:50051 
  7. Summary:
  8.   Count:    10000
  9.   Total:    50.05 s
  10.   Slowest:  56.17 ms
  11.   Fastest:  50.17 ms
  12.   Average:  50.58 ms
  13.   Requests/sec: 199.79
  15. Response time histogram:
  16.   50.167 [1]    |
  17.   50.768 [8056] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  18.   51.368 [1900] |∎∎∎∎∎∎∎∎∎
  19.   51.968 [37]   |
  20.   52.568 [1]    |
  21.   53.169 [0]    |
  22.   53.769 [0]    |
  23.   54.369 [1]    |
  24.   54.969 [1]    |
  25.   55.569 [0]    |
  26.   56.170 [3]    |
  28. Latency distribution:
  29.   10 % in 50.32 ms
  30.   25 % in 50.40 ms
  31.   50 % in 50.56 ms
  32.   75 % in 50.72 ms
  33.   90 % in 50.88 ms
  34.   95 % in 51.00 ms
  35.   99 % in 51.23 ms
  37. Status code distribution:
  38.   [OK]   10000 responses

This will perform a constant load RPS against the server. Graphed, it may look like this:

Constant Load

Step Up RPS

  1. ghz --insecure --async --proto /protos/helloworld.proto \
  2.   --call helloworld.Greeter/SayHello \
  3.   -c 10 -n 10000 \
  4.   --load-schedule=step --load-start=50 --load-end=150 --load-step=10 --load-step-duration=5s \
  5.   -d '{"name":"{{.WorkerID}}"}' 0.0.0.0:50051 
  7. Summary:
  8.   Count:    10000
  9.   Total:    85.05 s
  10.   Slowest:  60.16 ms
  11.   Fastest:  50.18 ms
  12.   Average:  51.10 ms
  13.   Requests/sec: 117.57
  15. Response time histogram:
  16.   50.181 [1]    |
  17.   51.179 [5713] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  18.   52.177 [3923] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  19.   53.174 [311]  |∎∎
  20.   54.172 [46]   |
  21.   55.170 [0]    |
  22.   56.168 [1]    |
  23.   57.166 [1]    |
  24.   58.164 [2]    |
  25.   59.161 [0]    |
  26.   60.159 [2]    |
  28. Latency distribution:
  29.   10 % in 50.48 ms
  30.   25 % in 50.68 ms
  31.   50 % in 51.07 ms
  32.   75 % in 51.41 ms
  33.   90 % in 51.68 ms
  34.   95 % in 52.02 ms
  35.   99 % in 52.77 ms
  37. Status code distribution:
  38.   [OK]   10000 responses

Performs step load starting at 50 RPS and inscreasing by 10 RPS every 5s until we reach 150 RPS at which point the load is sustained at constant RPS rate until we reach 10000 total requests. The RPS load is distributed among the 10 workers, all sharing 1 connection.

Step Up Load

Step Down RPS

  1. ghz --insecure --async --proto /protos/helloworld.proto \
  2.   --call helloworld.Greeter/SayHello \
  3.   -c 10 -n 10000 \
  4.   --load-schedule=step --load-start=200 --load-step=-10 --load-step-duration=5s --load-max-duration=40s \
  5.   -d '{"name":"{{.WorkerID}}"}' 0.0.0.0:50051 
  7. Summary:
  8.   Count:    10000
  9.   Total:    68.38 s
  10.   Slowest:  55.88 ms
  11.   Fastest:  50.16 ms
  12.   Average:  50.85 ms
  13.   Requests/sec: 146.23
  15. Response time histogram:
  16.   50.159 [1]    |
  17.   50.730 [4367] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  18.   51.302 [4281] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  19.   51.874 [1304] |∎∎∎∎∎∎∎∎∎∎∎∎
  20.   52.446 [43]   |
  21.   53.018 [0]    |
  22.   53.590 [0]    |
  23.   54.162 [2]    |
  24.   54.734 [0]    |
  25.   55.306 [0]    |
  26.   55.877 [2]    |
  28. Latency distribution:
  29.   10 % in 50.45 ms
  30.   25 % in 50.60 ms
  31.   50 % in 50.77 ms
  32.   75 % in 51.06 ms
  33.   90 % in 51.38 ms
  34.   95 % in 51.54 ms
  35.   99 % in 51.79 ms
  37. Status code distribution:
  38.   [OK]   10000 responses

Performs step load starting at 200 RPS and decreasing by 10 RPS every 10s until 40s has elapsed at which point the load is sustained at that RPS rate until we reach 10000 total requests. The RPS load is distributed among the 10 workers, all sharing 1 connection.

Step Down Load

Linear load

  1. ghz --insecure --async --proto /protos/helloworld.proto \
  2.   --call helloworld.Greeter/SayHello \
  3.   -c 10 -n 10000 \
  4.   --load-schedule=line --load-start=5 --load-step=5 \
  5.   -d '{"name":"{{.WorkerID}}"}' 0.0.0.0:50051
  7. Summary:
  8.   Count:    10000
  9.   Total:    62.80 s
  10.   Slowest:  56.61 ms
  11.   Fastest:  50.19 ms
  12.   Average:  50.72 ms
  13.   Requests/sec: 159.24
  15. Response time histogram:
  16.   50.189 [1]    |
  17.   50.832 [7552] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  18.   51.474 [1781] |∎∎∎∎∎∎∎∎∎
  19.   52.117 [405]  |∎∎
  20.   52.759 [139]  |∎
  21.   53.402 [42]   |
  22.   54.044 [28]   |
  23.   54.687 [28]   |
  24.   55.329 [10]   |
  25.   55.972 [13]   |
  26.   56.614 [1]    |
  28. Latency distribution:
  29.   10 % in 50.34 ms
  30.   25 % in 50.42 ms
  31.   50 % in 50.57 ms
  32.   75 % in 50.82 ms
  33.   90 % in 51.22 ms
  34.   95 % in 51.68 ms
  35.   99 % in 53.16 ms
  37. Status code distribution:
  38.   [OK]   10000 responses

Performs linear load starting at 5 RPS and increasing by 5 RPS every 1s until we reach 10000 total requests. The RPS load is distributed among the 10 workers, all sharing 1 connection.

Linear Up Load

Linear load decrease

  1. ghz --insecure --async --proto /protos/helloworld.proto \
  2.   --call helloworld.Greeter/SayHello \
  3.   -c 10 -n 10000 \
  4.   --load-schedule=line --load-start=200 --load-step=-2 --load-end=100 \
  5.   -d '{"name":"{{.WorkerID}}"}' 0.0.0.0:50051 
  7. Summary:
  8.   Count:    10000
  9.   Total:    74.55 s
  10.   Slowest:  83.20 ms
  11.   Fastest:  50.18 ms
  12.   Average:  50.89 ms
  13.   Requests/sec: 134.13
  15. Response time histogram:
  16.   50.183 [1]    |
  17.   53.486 [9989] |∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎∎
  18.   56.788 [5]    |
  19.   60.090 [1]    |
  20.   63.392 [3]    |
  21.   66.694 [0]    |
  22.   69.996 [0]    |
  23.   73.298 [0]    |
  24.   76.600 [0]    |
  25.   79.902 [0]    |
  26.   83.205 [1]    |
  28. Latency distribution:
  29.   10 % in 50.42 ms
  30.   25 % in 50.57 ms
  31.   50 % in 50.77 ms
  32.   75 % in 51.11 ms
  33.   90 % in 51.49 ms
  34.   95 % in 51.73 ms
  35.   99 % in 52.15 ms
  37. Status code distribution:
  38.   [OK]   10000 responses

Performs linear load starting at 200 RPS and decreasing by 2 RPS every 1s until we reach 100 RPS at which point a constant rate is sustained until we accumulate 10000 total requests. The RPS load is distributed among the 10 workers, all sharing 1 connection.

Linear Down Load