-
Notifications
You must be signed in to change notification settings - Fork 4
/
README
109 lines (88 loc) · 4.62 KB
/
README
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
DistWalk - Distributed processing emulation tool for Linux
Copyright 2016-2021 by Tommaso Cucinotta
firstname dot lastname at santannapisa dot it
======================================================================
DESCRIPTION
----------------------------------------------------------------------
DistWalk is a simple command-line tool useful to emulate distributed
processing scenarios, where a client submits requests to be processed
by one or more server nodes, in a distributed environment. The client
can be configured to send requests according to a pre-defined pattern
(e.g., periodically or exponentially distributed), where requests may
ask the server to perform processing for a time that is configurable
according to a pre-defined pattern (e.g., constant or exponentially
distributed processing time), or performing disk operations by reading
or writing a configurable amount of data.
The client provides, at the end of the experiment, all the end-to-end
processing times for all submitted requests.
The client establishes one or more TCP connections to the server,
which is capable of handling multiple client connections via epoll(7).
The client can submit concurrent traffic by spawning multiple threads.
Furthermore, each thread can emulate different sessions where the
connection is closed and re-established for each new session.
The client, or the node, can forward a sequence of instructions
to N different nodes and await the response of M nodes (N>=M).
COMPILING
----------------------------------------------------------------------
This program has been developed and tested on a Linux Ubuntu system,
versions from 16.xx to 21.xx. Therefore, please, use Linux.
In order to compile the client and the server, just type, from the
root folder:
make
two executables are created:
- src/dw_client: the client program, try typing ./dw_client -h
- src/dw_node: the server program, try typing ./dw_node -h
For debug/development purposes, compile the executables, from the root folder:
make debug
two executables are created:
- src/dw_client_debug: the client program with logging activated
- src/dw_node_debug: the server program with logging activated
- src/dw_client_tsan: the client program with logging and thread sanitizer activated
- src/dw_node_tsan: the server program with logging and thread sanitizer activated
EXAMPLES OF USE
----------------------------------------------------------------------
The classic and simplest scenario is the one of a client-server
scenario with client submitting periodically packets of a given
size, and expecting back responses of a different fixed size.
This example scenario is achieved launching on the server the simple
command:
[myuser@myserver distwalk/src]$ ./dw_node
then launching on the client the following command, with which we are
submitting 10 packets at a rate of 1000 pkt/s
[myuser@myclient distwalk/src]$ ./src/dw_client -n 10 -r 1000 -C 1000 --ps 512
Configuration:
clienthost=0.0.0.0:0
serverhost=127.0.0.1:7891
num_threads: 1
num_pkts=10 (COMPUTE:1, STORE:0, LOAD:0)
rate=1000, exp_arrivals=0
period=1000us
waitspin=0
ramp_num_steps=0, ramp_delta_rate=0, ramp_step_secs=0
pkt_size=512 (+66 for headers)
min packet size due to header: send=20, reply=12
max packet size: 16777216
no_delay: 1
num_sessions: 1
per_session_output: 0
request template: ccmd COMPUTE(1000us)->REPLY(512b,1)
t: 271 us, elapsed: 1100 us, req_id: 0, thr_id: 0, sess_id: 0
t: 1355 us, elapsed: 1026 us, req_id: 1, thr_id: 0, sess_id: 0
t: 2366 us, elapsed: 1024 us, req_id: 2, thr_id: 0, sess_id: 0
t: 3354 us, elapsed: 1045 us, req_id: 3, thr_id: 0, sess_id: 0
t: 4355 us, elapsed: 1050 us, req_id: 4, thr_id: 0, sess_id: 0
t: 5358 us, elapsed: 1065 us, req_id: 5, thr_id: 0, sess_id: 0
t: 6356 us, elapsed: 1073 us, req_id: 6, thr_id: 0, sess_id: 0
t: 7358 us, elapsed: 1081 us, req_id: 7, thr_id: 0, sess_id: 0
t: 8347 us, elapsed: 1097 us, req_id: 8, thr_id: 0, sess_id: 0
t: 9325 us, elapsed: 1136 us, req_id: 9, thr_id: 0, sess_id: 0
The following command spawns 4 threads submitting concurrently
requests to the same server (each thread submits 5000 requests needing
a 1ms of processing time each, at a rate of 250 pkt/s):
[myuser@myclient distwalk/src]$ ./dw_client --nt 4 -n 5000 -r 250 -C 1000
The following command spawns 3 threads, with each of them using 10
sessions to submit the 5000 packets as in the above command, so each
session will send 500 requests at a rate of 250 pkt/s (at the end of
each session, each client thread closes the connection and establishes
a new connection for the subsequent session)
[myuser@myclient distwalk/src]$ ./dw_client --nt 3 --ns 10 -n 5000 -r 250 -C 1000