1RDS-STRESS(1) BSD General Commands Manual RDS-STRESS(1)
2
4 rds-stress — send messages between processes over RDS sockets
5
7 rds-stress [-p port_number] [-r receive_address] [-s send_address]
8 [-a ack_bytes] [-q request_bytes] [-D rdma_bytes]
9 [-d queue_depth] [-t nr_tasks] [-c] [-R] [-V] [-v]
10
13 rds-stress sends messages between groups tasks, usually running on seper‐
14 ate machines.
15 First a passive receiving instance is started.
17 $ rds-stress
19 Then an active sending instance is started, giving it the address and
21 port at which it will find a listening passive receiver. In addition, it
22 is given configuration options which both instances will use.
23 $ rds-stress -s recvhost -p 4000 -t 1 -d 1
25 The active sender will parse the options, connect to the passive
27 receiver, and send the options over this connection. From this point on
28 both instances exhibit the exact same behaviour.
29 They will create a number of child tasks as specified by the -t option.
31 Once the children are created the parent sleeps for a second at a time,
32 printing a summary of statistics at each interval.
33 Each child will open an RDS socket, each binding to a port number in
35 order after the port number given on the command line. The first child
36 would bind to port 4001 in our example. Each child sets the send and
37 receive buffers to exactly fit the number of messages, requests and acks,
38 that will be in flight as determind by the command line arguments.
39 The children then enter their loop. They will keep a number of sent mes‐
41 sages outstanding as specified by the -d option. When they reach this
42 limit they will wait to receive acks which will allow them to send again.
43 As they receive messages from their peers they immediately send acks.
44 Every second, the parent process will display statistics of the ongoing
46 stress test. The output is described in section OUTPUT below.
47 If the -T option is given, the test will terminate after the specified
49 time, and a summary is printed.
50 Each child maintains outstanding messages to all other children of the
52 other instance. They do not send to their siblings.
53
55 The following options are available for use on the command line:
56 -p port_number
58 Each parent binds a TCP socket to this port number and their
59 respective address. They will trade the negotiated options over
60 this socket. Each child will bind an RDS socket to the range of
61 ports immediately following this port number, for as many chil‐
62 dren as there are.
63 -s send_address
65 A connection attempt is made to this address. Once its complete
66 and the options are sent over it then children will be created
67 and work will proceed.
68 -r receive_address
70 This specifies the address that messages will be sent from. If
71 -s is not specified then rds-stress waits for a connection on
72 this address before proceeding.
73 If this option is not given, rds-stress will choose an appropri‐
75 ate address. The passive process will accept connections on all
76 local interfaces, and obtain the address once the control connec‐
77 tion is established. The active process will choose a local
78 address based on the interface through which it connects to the
79 destination address.
80 -a ack_bytes
82 This specifies the size of the ack messages, in bytes. There is a
83 minimum size which depends on the format of the ack messages,
84 which may change over time. See section "Message Sizes" below.
85 -q request_bytes
87 This specifies the size of the request messages, in bytes. It
88 also has a minimum size which may change over time. See section
89 "Message Sizes" below.
90 -D rdma_bytes
92 RDSv3 is capable of transmitting part of a message via RDMA
93 directly from application buffer to application buffer. This
94 option enables RDMA support in rds-stress: request packets
95 include parameters for an RDMA READ or WRITE operation, which the
96 receiving process executes at the time the ACK packet is sent.
97 See section "Message Sizes" below.
98 -d queue_depth
100 Each child will try to maintain this many sent messages outstand‐
101 ing to each of its peers on the remote address.
102 -t nr_tasks
104 Each parent will create this many children tasks.
105 -T seconds
107 Specify the duration of the test run. After the specified number
108 of seconds, all processes on both ends of the connection will
109 terminate, and the active instance will print a summary. By
110 default, rds-stress will keep on sending and receiving messages.
111 -z This flag can be used in conjunction with -T. It suppresses the
113 ongoing display of statistics, and prints a summary only.
114 -c This causes rds-stress to create child tasks which just consume
116 CPU cycles. One task is created for each CPU in the system.
117 First each child observes the maximum rate at which it can con‐
118 sume cycles. This means that this option should only be given on
119 an idle system. rds-stress can then calculate the CPU use of the
120 system by observing the lesser rate at which the children consume
121 cycles. This option is *not* shared between the active and pas‐
122 sive instances. It must be specified on each rds-stress command
123 line.
124 -R This tells the rds-stress parent process to run with SCHED_RR
126 priority, giving it precedence over the child processes. This is
127 useful when running with lots of tasks, where there is a risk of
128 the child processes starving the parent, and skewing the results.
129 -v With this option enabled, packets are filled with a pattern that
131 is verified by the receiver. This check can help detect data cor‐
132 ruption occuring under high load.
133 Message Sizes
135 Options which set a message size (such as -a) specify a number of bytes
136 by default. By appending K, M, or G, you can specify the size in kilo‐
137 bytes, megabytes or gigabytes, respectively. For instance, the following
138 will run rds-stress with a message and ACK size of 1024 bytes, and an
139 RDMA message size of 1048576 bytes:
140 rds-stress ... -q 1K -a 1K -D 1M
142
144 Each parent outputs columns of statistics at a regular interval:
145 tsks The number of child tasks which are running.
147 tx/s The number of sendmsg() calls that all children are executing,
149 per second.
150 tx+rx K/s
152 The total number of bytes that are flowing through sendmsg() and
153 recvmsg() for all children. This includes both request and ack
154 messages.
155 rw+rr K/s
157 The total number of bytes that are being transferred via RDMA
158 READs and WRITEs for all children.
159 tx us/c
161 The average number of microseconds spent in sendmsg() calls.
162 rtt us The average round trip time for a request and ack message pair.
164 This measures the total time between when a task sends a request
165 and when it finally receives the ack for that message. Because
166 it includes the time it takes for the receiver to wake up,
167 receive the message, and send an ack, it can grow to be quite
168 large under load.
169 cpu % This is the percentage of available CPU resources on this machine
171 that are being consumed since rds-stress started running. It
172 will show -1.00 if -c is not given. It is calculated based on
173 the amount of CPU resources that CPU soaking tasks are able to
174 consume. This lets it measure CPU use by the system, say in
175 interrupt handlers, that task-based CPU accounting does not
176 include. For this to work rds-stress must be started with -c on
177 an idle system.
178BSD May 15, 2007 BSD