Debian Codegraph @

test/dapltest/README

raw
1
2 NAME
3
4 dapltest - test for the Direct Access Programming Library (DAPL)
5
6 DESCRIPTION
7
8 Dapltest is a set of tests developed to exercise, characterize,
9 and verify the DAPL interfaces during development and porting.
10 At least two instantiations of the test must be run. One acts
11 as the server, fielding requests and spawning server-side test
12 threads as needed. Other client invocations connect to the
13 server and issue test requests.
14
15 The server side of the test, once invoked, listens continuously
16 for client connection requests, until quit or killed. Upon
17 receipt of a connection request, the connection is established,
18 the server and client sides swap version numbers to verify that
19 they are able to communicate, and the client sends the test
20 request to the server. If the version numbers match, and the
21 test request is well-formed, the server spawns the threads
22 needed to run the test before awaiting further connections.
23
24 USAGE
25
26 dapltest [ -f script_file_name ]
27 [ -T S|Q|T|P|L ] [ -D device_name ] [ -d ] [ -R HT|LL|EC|PM|BE ]
28
29 With no arguments, dapltest runs as a server using default values,
30 and loops accepting requests from clients. The -f option allows
31 all arguments to be placed in a file, to ease test automation.
32 The following arguments are common to all tests:
33
34 [ -T S|Q|T|P|L ] Test function to be performed:
35 S - server loop
36 Q - quit, client requests that server
37 wait for any outstanding tests to
38 complete, then clean up and exit
39 T - transaction test, transfers data between
40 client and server
41 P - performance test, times DTO operations
42 L - limit test, exhausts various resources,
43 runs in client w/o server interaction
44 Default: S
45
46 [ -D device_name ] Specifies the name of the device (interface adapter).
47 Default: host-specific, look for DT_MdepDeviceName
48 in dapl_mdep.h
49
50 [ -d ] Enables extra debug verbosity, primarily tracing
51 of the various DAPL operations as they progress.
52 Repeating this parameter increases debug spew.
53 Errors encountered result in the test spewing some
54 explanatory text and stopping; this flag provides
55 more detail about what lead up to the error.
56 Default: zero
57
58 [ -R BE ] Indicate the quality of service (QoS) desired.
59 Choices are:
60 HT - high throughput
61 LL - low latency
62 EC - economy (neither HT nor LL)
63 PM - premium
64 BE - best effort
65 Default: BE
66
67 USAGE - Quit test client
68
69 dapltest [Common_Args] [ -s server_name ]
70
71 Quit testing (-T Q) connects to the server to ask it to clean up and
72 exit (after it waits for any outstanding test runs to complete).
73 In addition to being more polite than simply killing the server,
74 this test exercises the DAPL object teardown code paths.
75 There is only one argument other than those supported by all tests:
76
77 -s server_name Specifies the name of the server interface.
78 No default.
79
80
81 USAGE - Transaction test client
82
83 dapltest [Common_Args] [ -s server_name ]
84 [ -t threads ] [ -w endpoints ] [ -i iterations ] [ -Q ]
85 [ -V ] [ -P ] OPclient OPserver [ op3,
86
87 Transaction testing (-T T) transfers a variable amount of data between
88 client and server. The data transfer can be described as a sequence of
89 individual operations; that entire sequence is transferred 'iterations'
90 times by each thread over all of its endpoint(s).
91
92 The following parameters determine the behavior of the transaction test:
93
94 -s server_name Specifies the name of the server interface.
95 No default.
96
97 [ -t threads ] Specify the number of threads to be used.
98 Default: 1
99
100 [ -w endpoints ] Specify the number of connected endpoints per thread.
101 Default: 1
102
103 [ -i iterations ] Specify the number of times the entire sequence
104 of data transfers will be made over each endpoint.
105 Default: 1000
106
107 [ -Q ] Funnel completion events into a CNO.
108 Default: use EVDs
109
110 [ -V ] Validate the data being transferred.
111 Default: ignore the data
112
113 [ -P ] Turn on DTO completion polling
114 Default: off
115
116 OP1 OP2 [ OP3, ... ]
117 A single transaction (OPx) consists of:
118
119 server|client Indicates who initiates the
120 data transfer.
121
122 SR|RR|RW Indicates the type of transfer:
123 SR send/recv
124 RR RDMA read
125 RW RDMA write
126 Defaults: none
127
128 [ seg_size [ num_segs ] ]
129 Indicates the amount and format
130 of the data to be transferred.
131 Default: 4096 1
132 (i.e., 1 4KB buffer)
133
134 [ -f ] For SR transfers only, indicates
135 that a client's send transfer
136 completion should be reaped when
137 the next recv completion is reaped.
138 Sends and receives must be paired
139 (one client, one server, and in that
140 order) for this option to be used.
141
142 Restrictions:
143
144 Due to the flow control algorithm used by the transaction test, there
145 must be at least one SR OP for both the client and the server.
146
147 Requesting data validation (-V) causes the test to automatically append
148 three OPs to those specified. These additional operations provide
149 synchronization points during each iteration, at which all user-specified
150 transaction buffers are checked. These three appended operations satisfy
151 the "one SR in each direction" requirement.
152
153 The transaction OP list is printed out if -d is supplied.
154
155 USAGE - Performance test client
156
157 dapltest [Common_Args] -s server_name [ -m p|b ]
158 [ -i iterations ] [ -p pipeline ] OP
159
160 Performance testing (-T P) times the transfer of an operation.
161 The operation is posted 'iterations' times.
162
163 The following parameters determine the behavior of the transaction test:
164
165 -s server_name Specifies the name of the server interface.
166 No default.
167
168 -m b|p Used to choose either blocking (b) or polling (p)
169 Default: blocking (b)
170
171 [ -i iterations ] Specify the number of times the entire sequence
172 of data transfers will be made over each endpoint.
173 Default: 1000
174
175 [ -p pipeline ] Specify the pipline length, valid arguments are in
176 the range [0,MAX_SEND_DTOS]. If a value greater than
177 MAX_SEND_DTOS is requested the value will be
178 adjusted down to MAX_SEND_DTOS.
179 Default: MAX_SEND_DTOS
180
181 OP
182 An operation consists of:
183
184 RR|RW Indicates the type of transfer:
185 RR RDMA read
186 RW RDMA write
187 Default: none
188
189 [ seg_size [ num_segs ] ]
190 Indicates the amount and format
191 of the data to be transferred.
192 Default: 4096 1
193 (i.e., 1 4KB buffer)
194
195 USAGE - Limit test client
196
197 Limit testing (-T L) neither requires nor connects to any server
198 instance. The client runs one or more tests which attempt to
199 exhaust various resources to determine DAPL limits and exercise
200 DAPL error paths. If no arguments are given, all tests are run.
201
202 Limit testing creates the sequence of DAT objects needed to
203 move data back and forth, attempting to find the limits supported
204 for the DAPL object requested. For example, if the LMR creation
205 limit is being examined, the test will create a set of
206 {IA, PZ, CNO, EVD, EP} before trying to run dat_lmr_create() to
207 failure using that set of DAPL objects. The 'width' parameter
208 can be used to control how many of these parallel DAPL object
209 sets are created before beating upon the requested constructor.
210 Use of -m limits the number of dat_*_create() calls that will
211 be attempted, which can be helpful if the DAPL in use supports
212 essentailly unlimited numbers of some objects.
213
214 The limit test arguments are:
215
216 [ -m maximum ] Specify the maximum number of dapl_*_create()
217 attempts.
218 Default: run to object creation failure
219
220 [ -w width ] Specify the number of DAPL object sets to
221 create while initializing.
222 Default: 1
223
224 [ limit_ia ] Attempt to exhaust dat_ia_open()
225
226 [ limit_pz ] Attempt to exhaust dat_pz_create()
227
228 [ limit_cno ] Attempt to exhaust dat_cno_create()
229
230 [ limit_evd ] Attempt to exhaust dat_evd_create()
231
232 [ limit_ep ] Attempt to exhaust dat_ep_create()
233
234 [ limit_rsp ] Attempt to exhaust dat_rsp_create()
235
236 [ limit_psp ] Attempt to exhaust dat_psp_create()
237
238 [ limit_lmr ] Attempt to exhaust dat_lmr_create(4KB)
239
240 [ limit_rpost ] Attempt to exhaust dat_ep_post_recv(4KB)
241
242 [ limit_size_lmr ] Probe maximum size dat_lmr_create()
243
244 Default: run all tests
245
246
247 EXAMPLES
248
249 dapltest -T S -d -D jni0a
250
251 Starts a server process with debug verbosity.
252
253 dapltest -T T -d -s linux3 -D jni0a -i 100 \
254 client SR 4096 2 server SR 4096 2
255
256 Runs a transaction test, with both sides
257 sending one buffer with two 4KB segments,
258 one hundred times.
259
260 dapltest -T P -d -s linux3 -D JniIbdd0 -i 100 SR 4096 2
261
262 Runs a performance test, with the client
263 sending one buffer with two 4KB segments,
264 one hundred times.
265
266 dapltest -T Q -s linux3 -D jni0a
267
268 Asks the server to clean up and exit.
269
270 dapltest -T L -D jni0a -d -w 16 -m 1000
271
272 Runs all of the limit tests, setting up
273 16 complete sets of DAPL objects, and
274 creating at most a thousand instances
275 when trying to exhaust resources.
276
277 dapltest -T T -V -d -t 2 -w 4 -i 55555 -s linux3 -D jni0a \
278 client RW 4096 1 server RW 2048 4 \
279 client SR 1024 4 server SR 4096 2 \
280 client SR 1024 3 -f server SR 2048 1 -f
281
282 Runs a more complicated transaction test,
283 with two thread using four EPs each,
284 sending a more complicated buffer pattern
285 for a larger number of iterations,
286 validating the data received.
287
288
289 BUGS (and To Do List)
290
291 Use of CNOs (-Q) is not yet supported.
292
293 Further limit tests could be added.