[netperf-dev] netperf4 commit notice r177 - trunk/src
burger at netperf.org
burger at netperf.org
Wed May 17 11:30:59 PDT 2006
Author: burger
Date: 2006-05-17 11:30:57 -0700 (Wed, 17 May 2006)
New Revision: 177
Modified:
trunk/src/disktest.c
trunk/src/nettest_bsd.c
trunk/src/nettest_bsd.h
Log:
Fix to make sequential disk write tests work.
Added udp tests to nettest_bsd code compiles not yet working.
Added First burst code to send_tcp_rr test.
Stephen Burger
Modified: trunk/src/disktest.c
===================================================================
--- trunk/src/disktest.c 2006-05-02 22:10:46 UTC (rev 176)
+++ trunk/src/disktest.c 2006-05-17 18:30:57 UTC (rev 177)
@@ -102,7 +102,8 @@
{
int loc_debug = 1;
if (test->debug || loc_debug) {
- fprintf(test->where,"%s: called report_test_failure:",function);
+ fprintf(test->where,"%s - %s: called report_test_failure:",
+ (char *)test->id,function);
fprintf(test->where,"reporting %s errno = %d\n",err_string,GET_ERRNO);
fflush(test->where);
}
@@ -966,6 +967,7 @@
DISK_TEST_RDWR_OPEN_FAILED,
"read/write open of file_name failed");
}
+ my_data->fd = fd;
}
/* seek to the starting location on the disk */
@@ -1137,7 +1139,7 @@
outfd = stdout;
}
/* allocate and initialize report data */
- malloc_size = sizeof(disk_results_t) + 7 * max_count * sizeof(double);
+ malloc_size = sizeof(disk_results_t) + 8 * max_count * sizeof(double);
rd = malloc(malloc_size);
if (rd) {
@@ -1266,15 +1268,15 @@
seek_call_rate = test_cntr[TST_S_CALLS] / elapsed_seconds;
iops = read_call_rate + write_call_rate;
if (test_set->debug) {
- fprintf(test_set->where,"\tread_rate = %7g\t%7g\n",
+ fprintf(test_set->where,"\tread_rate = %7g\t%7g\n",
read_rate, test_cntr[TST_R_BYTES]);
- fprintf(test_set->where,"\twrite_rate = %7g\t%7g\n",
+ fprintf(test_set->where,"\twrite_rate = %7g\t%7g\n",
write_rate, test_cntr[TST_W_BYTES]);
- fprintf(test_set->where,"\tread_call_rate = %7g\t%7g\n",
+ fprintf(test_set->where,"\tread_call_rate = %7g\t%7g\n",
read_call_rate, test_cntr[TST_R_CALLS]);
fprintf(test_set->where,"\twrite_call_rate = %7g\t%7g\n",
write_call_rate, test_cntr[TST_W_CALLS]);
- fprintf(test_set->where,"\tseek_call_rate = %7g\t%7g\n",
+ fprintf(test_set->where,"\tseek_call_rate = %7g\t%7g\n",
seek_call_rate, test_cntr[TST_S_CALLS]);
fflush(test_set->where);
}
@@ -1293,6 +1295,21 @@
rd->write_iops[index] += write_call_rate;
rd->iops[index] += iops;
+ if (test_set->debug) {
+ fprintf(test_set->where,"\trun_time[%d] = %7g\n",
+ index, rd->run_time[index]);
+ fprintf(test_set->where,"\tread_results[%d] = %7g\n",
+ index, rd->read_results[index]);
+ fprintf(test_set->where,"\twrite_results[%d] = %7g\n",
+ index, rd->write_results[index]);
+ fprintf(test_set->where,"\tread_iops[%d] = %7g\n",
+ index, rd->read_iops[index]);
+ fprintf(test_set->where,"\twrite_iops[%d] = %7g\n",
+ index, rd->write_iops[index]);
+ fprintf(test_set->where,"\tiops[%d] = %7g\n",
+ index, rd->iops[index]);
+ fflush(test_set->where);
+ }
if (rd->print_hist) {
xmlNodePtr hist;
hist = stats->xmlChildrenNode;
@@ -1513,7 +1530,7 @@
while (stats != NULL) {
/* process all the statistics records for this test */
if (test_set->debug) {
- fprintf(test_set->where,"\tfound some statistics");
+ fprintf(test_set->where,"\tfound some statistics\n");
fflush(test_set->where);
}
if(!xmlStrcmp(stats->name,(const xmlChar *)"sys_stats")) {
Modified: trunk/src/nettest_bsd.c
===================================================================
--- trunk/src/nettest_bsd.c 2006-05-02 22:10:46 UTC (rev 176)
+++ trunk/src/nettest_bsd.c 2006-05-17 18:30:57 UTC (rev 177)
@@ -42,7 +42,6 @@
#define MAKE_DIRTY(mydata,ring) /* DIRTY is not currently supported */
#endif
-
/****************************************************************/
/* */
/* nettest_bsd.c */
@@ -53,6 +52,10 @@
/* recv_tcp_stream() catch a tcp stream test */
/* send_tcp_rr() perform a tcp req/rsp test */
/* recv_tcp_rr() catch a tcp req/rsp test */
+/* send_udp_stream() perform a udp stream test */
+/* recv_udp_stream() catch a udp stream test */
+/* send_udp_rr() perform a udp req/rsp test */
+/* recv_udp_rr() catch a udp req/rsp test */
/* */
/****************************************************************/
@@ -130,13 +133,59 @@
#define GET_ERRNO errno
#endif
-/* Macros for accessing fields in the global netperf structures. */
-#define SET_TEST_STATE(state) test->new_state = state
-#define GET_TEST_STATE test->new_state
-#define CHECK_REQ_STATE test->state_req
-#define GET_TEST_DATA(test) test->test_specific_data
+#if !defined(WANT_FIRST_BURST)
+#define BURST_VARS /* Burst variable declarations go here */
+#define TCP_CHECK_BURST_SEND /* Code to send tcp burst goes here */
+#define UDP_CHECK_FOR_RETRANS /* Code to retrans udp packets goes here */
+#define UDP_CHECK_BURST_SEND /* Code to send udp burst goes here */
+#define UDP_CHECK_BURST_RECV /* code for dropped udp packets goes here */
+#else
+#define TCP_CHECK_BURST_SEND \
+ if (my_data->burst_count > my_data->pending_responses) { \
+ my_data->pending_responses++; \
+ my_data->send_ring = my_data->send_ring->next; \
+ continue; \
+ }
+#define UDP_CHECK_FOR_RETRANS \
+ if (my_data->retry_array != NULL) { \
+ int retry; \
+ retry = my_data->retry_index; \
+ /* A burst size has been specified check if retransmission is needed */ \
+ if (my_data->retry_array[retry] != NULL) { \
+ /* a retransmission is needed a response was not received */ \
+ buffer_ptr = my_data->retry_array[retry]; \
+ } \
+ buffer_ptr[0] = retry; \
+ }
+#define UDP_CHECK_BURST_SEND \
+ if (my_data->retry_array != NULL) { \
+ int retry = my_data->retry_index; \
+ int pending = my_data->pending_responses; \
+ int burst = my_data->burst_count; \
+ if (my_data->retry_array[retry] == NULL) { \
+ my_data->retry_array[retry] = buffer_ptr; \
+ retry++; \
+ if (retry == burst) { \
+ retry = 0; \
+ } \
+ pending++; \
+ my_data->pending_responses = pending; \
+ my_data->retry_index = retry; \
+ if (pending < burst) { \
+ my_data->send_ring = my_data->send_ring->next; \
+ continue; \
+ } \
+ } \
+ }
+#define UDP_CHECK_BURST_RECV \
+ if (my_data->retry_array != NULL) {
+ my_data->retry_array[buffer_ptr[0]] = NULL; \
+ my_data->pending_responses--; \
+ }
+#endif
+
static void
report_test_failure(test, function, err_code, err_string)
test_t *test;
@@ -238,9 +287,9 @@
{
while (GET_TEST_STATE != TEST_DEAD) {
if (CHECK_REQ_STATE == TEST_DEAD) {
- free(test->test_specific_data);
- test->test_specific_data = NULL;
- test->new_state = TEST_DEAD;
+ free(GET_TEST_DATA(test));
+ SET_TEST_DATA(test,NULL);
+ SET_TEST_STATE(TEST_DEAD);
}
}
}
@@ -353,7 +402,7 @@
static void
get_dependency_data(test_t *test, int type, int protocol)
{
- bsd_data_t *my_data = test->test_specific_data;
+ bsd_data_t *my_data = GET_TEST_DATA(test);
xmlChar *string;
xmlChar *remotehost;
@@ -401,12 +450,12 @@
my_data->remaddr = remote_ai;
} else {
if (test->debug) {
- fprintf(test->where,"get_dependency_data: getaddrinfo returned %d %s\n",
- error, gai_strerror(error));
+ fprintf(test->where,"%s: getaddrinfo returned %d %s\n",
+ __func__, error, gai_strerror(error));
fflush(test->where);
}
report_test_failure(test,
- "get_dependency_data",
+ (char *)__func__,
BSDE_GETADDRINFO_ERROR,
gai_strerror(error));
}
@@ -418,7 +467,7 @@
test_t *test;
{
- bsd_data_t *my_data = test->test_specific_data;
+ bsd_data_t *my_data = GET_TEST_DATA(test);
xmlChar *family;
char port[8];
char host[32];
@@ -579,7 +628,7 @@
create_data_socket(test)
test_t *test;
{
- bsd_data_t *my_data = test->test_specific_data;
+ bsd_data_t *my_data = GET_TEST_DATA(test);
int family = my_data->locaddr->ai_family;
int type = my_data->locaddr->ai_socktype;
@@ -594,8 +643,8 @@
if (test->debug) {
fprintf(test->where,
- "create_data_socket: calling socket family = %d type = %d\n",
- family, type);
+ "%s: calling socket family = %d type = %d\n",
+ __func__, family, type);
fflush(test->where);
}
/*set up the data socket */
@@ -605,7 +654,7 @@
if (CHECK_FOR_INVALID_SOCKET) {
report_test_failure(test,
- "create_data_socket",
+ (char *)__func__,
BSDE_SOCKET_ERROR,
"error creating socket");
return(temp_socket);
@@ -613,8 +662,8 @@
if (test->debug) {
fprintf(test->where,
- "create_data_socket: socket %d obtained...\n",
- temp_socket);
+ "%s: socket %d obtained...\n",
+ __func__, temp_socket);
fflush(test->where);
}
@@ -636,7 +685,7 @@
if(setsockopt(temp_socket, SOL_SOCKET, SO_SNDBUF,
&lss_size, sizeof(int)) < 0) {
report_test_failure(test,
- "create_data_socket",
+ (char *)__func__,
BSDE_SETSOCKOPT_ERROR,
"error setting local send socket buffer size");
return(temp_socket);
@@ -653,15 +702,15 @@
if(setsockopt(temp_socket, SOL_SOCKET, SO_RCVBUF,
&lsr_size, sizeof(int)) < 0) {
report_test_failure(test,
- "create_data_socket",
+ (char *)__func__,
BSDE_SETSOCKOPT_ERROR,
"error setting local recv socket buffer size");
return(temp_socket);
}
if (test->debug > 1) {
fprintf(test->where,
- "nettest_bsd: create_data_socket: SO_RCVBUF of %d requested.\n",
- lsr_size);
+ "nettest_bsd: %s: SO_RCVBUF of %d requested.\n",
+ __func__, lsr_size);
fflush(test->where);
}
}
@@ -677,8 +726,8 @@
(char *)&lss_size,
&sock_opt_len) < 0) {
fprintf(test->where,
- "nettest_bsd: create_data_socket: getsockopt SO_SNDBUF: errno %d\n",
- errno);
+ "nettest_bsd: %s: getsockopt SO_SNDBUF: errno %d\n",
+ __func__, errno);
fflush(test->where);
lss_size = -1;
}
@@ -688,14 +737,15 @@
(char *)&lsr_size,
&sock_opt_len) < 0) {
fprintf(test->where,
- "nettest_bsd: create_data_socket: getsockopt SO_RCVBUF: errno %d\n",
- errno);
+ "nettest_bsd: %s: getsockopt SO_RCVBUF: errno %d\n",
+ __func__, errno);
fflush(test->where);
lsr_size = -1;
}
if (test->debug) {
fprintf(test->where,
- "nettest_bsd: create_data_socket: socket sizes determined...\n");
+ "nettest_bsd: %s: socket sizes determined...\n",
+ __func__);
fprintf(test->where,
" send: %d recv: %d\n",
lss_size,lsr_size);
@@ -722,7 +772,8 @@
&loc_rcvavoid,
sizeof(int)) < 0) {
fprintf(test->where,
- "nettest_bsd: create_data_socket: Could not enable receive copy avoidance");
+ "nettest_bsd: %s: Could not enable receive copy avoidance",
+ __func__);
fflush(test->where);
loc_rcvavoid = 0;
}
@@ -740,7 +791,8 @@
&loc_sndavoid,
sizeof(int)) < 0) {
fprintf(test->where,
- "netperf: create_data_socket: Could not enable send copy avoidance\n");
+ "nettest_bsd: %s: Could not enable send copy avoidance\n",
+ __func__);
fflush(test->where);
loc_sndavoid = 0;
}
@@ -765,14 +817,14 @@
(char *)&one,
sizeof(one)) < 0) {
fprintf(test->where,
- "netperf: create_data_socket: nodelay: errno %d\n",
- errno);
+ "nettest_bsd: %s: nodelay: errno %d\n",
+ __func__, errno);
fflush(test->where);
}
if (test->debug > 1) {
fprintf(test->where,
- "netperf: create_data_socket: TCP_NODELAY requested...\n");
+ "netperf: %s: TCP_NODELAY requested...\n", __func__);
fflush(test->where);
}
}
@@ -898,7 +950,28 @@
string = xmlGetProp(args,(const xmlChar *)"recv_offset");
new_data->recv_offset = atoi((char *)string);
- /* now get and initialize the local the local addressing info */
+ string = xmlGetProp(args,(const xmlChar *)"burst_count");
+ if (string) {
+ count = atoi((char *)string);
+ new_data->burst_count = count;
+ if (count >= new_data->send_width) {
+ new_data->send_width = count + 1;
+ }
+ string = xmlGetProp(test->node,(const xmlChar *)"test_name");
+ if (!xmlStrcmp(string, (const xmlChar *)"send_udp_rr")) {
+ new_data->retry_array = malloc(count * sizeof(char *));
+ if (new_data->retry_array) {
+ memset(new_data->retry_array, 0, count * sizeof(char *));
+ }
+ }
+ }
+
+ string = xmlGetProp(args,(const xmlChar *)"interval_time");
+ if (string) {
+ new_data->interval = atoi((char *)string);
+ }
+
+ /* now get and initialize the local addressing info */
string = xmlGetProp(args,(const xmlChar *)"family");
localfam = strtofam(string);
memset(&hints, 0, sizeof(hints));
@@ -931,23 +1004,23 @@
new_data->locaddr = local_ai;
} else {
if (test->debug) {
- fprintf(test->where,"bsd_test_init: getaddrinfo returned %d %s\n",
- error, gai_strerror(error));
+ fprintf(test->where,"%s: getaddrinfo returned %d %s\n",
+ __func__, error, gai_strerror(error));
fflush(test->where);
}
report_test_failure(test,
- "bsd_test_init",
+ (char *)__func__,
BSDE_GETADDRINFO_ERROR,
gai_strerror(error));
}
} else {
report_test_failure(test,
- "bsd_test_init",
+ (char *)__func__,
BSDE_NO_SOCKET_ARGS,
"no socket_arg element was found");
}
- test->test_specific_data = new_data;
+ SET_TEST_DATA(test,new_data);
return(new_data);
}
@@ -1093,12 +1166,10 @@
int rc;
int s_listen;
bsd_data_t *my_data;
- char *proc_name;
struct sockaddr myaddr;
netperf_socklen_t mylen;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_stream_preinit";
+ my_data = GET_TEST_DATA(test);
mylen = sizeof(myaddr);
my_data->recv_ring = allocate_buffer_ring(my_data->recv_width,
@@ -1113,29 +1184,29 @@
(xmlChar *)NULL, (xmlChar *)NULL, -1);
fprintf(test->where,
"%s:create_data_socket returned %d\n",
- proc_name, s_listen);
+ __func__, s_listen);
fflush(test->where);
}
rc = bind(s_listen, my_data->locaddr->ai_addr, my_data->locaddr->ai_addrlen);
if (test->debug) {
fprintf(test->where,
"%s:bind returned %d errno=%d\n",
- proc_name, rc, errno);
+ __func__, rc, errno);
fflush(test->where);
}
if (rc == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_BIND_FAILED,
"data socket bind failed");
} else if (listen(s_listen,5) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_LISTEN_FAILED,
"data socket listen failed");
} else if (getsockname(s_listen,&myaddr,&mylen) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_GETSOCKNAME_FAILED,
"getting the listen socket name failed");
} else {
@@ -1150,30 +1221,28 @@
{
int s_data;
bsd_data_t *my_data;
- char *proc_name;
struct sockaddr peeraddr;
netperf_socklen_t peerlen;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_stream_preinit";
+ my_data = GET_TEST_DATA(test);
peerlen = sizeof(peeraddr);
if (test->debug) {
- fprintf(test->where, "%s:waiting in accept\n", proc_name);
+ fprintf(test->where, "%s:waiting in accept\n", __func__);
fflush(test->where);
}
if ((s_data = accept(my_data->s_listen,
&peeraddr,
&peerlen)) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_ACCEPT_FAILED,
"listen socket accept failed");
} else {
if (test->debug) {
fprintf(test->where,
"%s:accept returned successfully %d\n",
- proc_name, s_data);
+ __func__, s_data);
fflush(test->where);
}
my_data->s_data = s_data;
@@ -1186,13 +1255,11 @@
{
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
struct sockaddr peeraddr;
netperf_socklen_t peerlen;
int len;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_stream_idle_link";
+ my_data = GET_TEST_DATA(test);
peerlen = sizeof(peeraddr);
len = last_len;
@@ -1204,7 +1271,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_RECV_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_RECV_ERROR,
"data_recv_error");
}
@@ -1213,7 +1280,7 @@
new_state = CHECK_REQ_STATE;
if (test->debug) {
- fprintf(test->where,"**** %s:new_state = %d\n",proc_name,new_state);
+ fprintf(test->where,"**** %s:new_state = %d\n",__func__,new_state);
fflush(test->where);
}
while (new_state == TEST_LOADED) {
@@ -1221,33 +1288,33 @@
new_state = CHECK_REQ_STATE;
}
if (test->debug) {
- fprintf(test->where,"**** %s:new_state = %d\n",proc_name,new_state);
+ fprintf(test->where,"**** %s:new_state = %d\n",__func__,new_state);
fflush(test->where);
}
if (new_state == TEST_IDLE) {
if (shutdown(my_data->s_data,SHUT_WR) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_SOCKET_SHUTDOWN_FAILED,
"failure shuting down data socket");
} else {
close(my_data->s_data);
if (test->debug) {
- fprintf(test->where,"%s: waiting in accept\n",proc_name);
+ fprintf(test->where,"%s: waiting in accept\n",__func__);
fflush(test->where);
}
if ((my_data->s_data=accept(my_data->s_listen,
&peeraddr,
&peerlen)) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_ACCEPT_FAILED,
"listen socket accept failed");
} else {
if (test->debug) {
fprintf(test->where,
"%s: accept returned successfully %d\n",
- proc_name,
+ __func__,
my_data->s_data);
fflush(test->where);
}
@@ -1257,7 +1324,7 @@
/* a transition to a state other than TEST_IDLE was requested
after the link was closed in the TEST_LOADED state */
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_CONNECTION_CLOSED_ERROR,
"data connection closed and non idle state requested");
@@ -1270,9 +1337,7 @@
int len;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_stream_meas";
+ my_data = GET_TEST_DATA(test);
HISTOGRAM_VARS;
/* code to make data dirty macro enabled by DIRTY */
MAKE_DIRTY(my_data, my_data->recv_ring);
@@ -1286,7 +1351,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_RECV_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_RECV_ERROR,
"data_recv_error");
} else {
@@ -1297,7 +1362,7 @@
} else {
/* how do we deal with a closed connection in the loaded state */
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_CONNECTION_CLOSED_ERROR,
"data connection closed during TEST_MEASURE state");
}
@@ -1320,10 +1385,8 @@
int len;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_stream_load";
+ my_data = GET_TEST_DATA(test);
/* code to make data dirty macro enabled by DIRTY */
MAKE_DIRTY(my_data, my_data->recv_ring);
@@ -1335,7 +1398,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_RECV_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_RECV_ERROR,
"data_recv_error");
} else {
@@ -1366,7 +1429,7 @@
{
bsd_data_t *my_data;
- my_data = test->test_specific_data;
+ my_data = GET_TEST_DATA(test);
if (my_data->s_data == 0) {
my_data->send_ring = allocate_buffer_ring(my_data->send_width,
@@ -1386,25 +1449,23 @@
send_tcp_stream_init(test_t *test)
{
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_stream_init";
+ my_data = GET_TEST_DATA(test);
if (test->debug) {
- fprintf(test->where,"%s: in INIT state making connect call\n",proc_name);
+ fprintf(test->where,"%s: in INIT state making connect call\n",__func__);
fflush(test->where);
}
if (connect(my_data->s_data,
my_data->remaddr->ai_addr,
my_data->remaddr->ai_addrlen) < 0) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_CONNECT_FAILED,
"data socket connect failed");
} else {
if (test->debug) {
- fprintf(test->where,"%s: connected and moving to IDLE\n",proc_name);
+ fprintf(test->where,"%s: connected and moving to IDLE\n",__func__);
fflush(test->where);
}
}
@@ -1415,18 +1476,16 @@
send_tcp_stream_idle_link(test_t *test)
{
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_stream_idle_link";
+ my_data = GET_TEST_DATA(test);
if (test->debug) {
- fprintf(test->where,"%s: transition from LOAD to IDLE\n",proc_name);
+ fprintf(test->where,"%s: transition from LOAD to IDLE\n",__func__);
fflush(test->where);
}
if (shutdown(my_data->s_data,SHUT_WR) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_SOCKET_SHUTDOWN_FAILED,
"failure shuting down data socket");
} else {
@@ -1436,19 +1495,19 @@
close(my_data->s_data);
my_data->s_data = create_data_socket(test);
if (test->debug) {
- fprintf(test->where,"%s: connecting from LOAD state\n",proc_name);
+ fprintf(test->where,"%s: connecting from LOAD state\n",__func__);
fflush(test->where);
}
if (connect(my_data->s_data,
my_data->remaddr->ai_addr,
my_data->remaddr->ai_addrlen) < 0) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_CONNECT_FAILED,
"data socket connect failed");
} else {
if (test->debug) {
- fprintf(test->where,"%s: connected moving to IDLE\n", proc_name);
+ fprintf(test->where,"%s: connected moving to IDLE\n", __func__);
fflush(test->where);
}
}
@@ -1461,10 +1520,8 @@
int len;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_stream_meas";
+ my_data = GET_TEST_DATA(test);
HISTOGRAM_VARS;
/* code to make data dirty macro enabled by DIRTY */
MAKE_DIRTY(my_data,my_data->send_ring);
@@ -1478,7 +1535,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_SEND_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_SEND_ERROR,
"data send error");
}
@@ -1505,10 +1562,8 @@
int len;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_stream_load";
+ my_data = GET_TEST_DATA(test);
HISTOGRAM_VARS;
/* code to make data dirty macro enabled by DIRTY */
@@ -1523,7 +1578,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_SEND_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_SEND_ERROR,
"data send_error");
}
@@ -1680,12 +1735,10 @@
int rc;
int s_listen;
bsd_data_t *my_data;
- char *proc_name;
struct sockaddr myaddr;
netperf_socklen_t mylen;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_rr_preinit";
+ my_data = GET_TEST_DATA(test);
mylen = sizeof(myaddr);
my_data->recv_ring = allocate_buffer_ring(my_data->recv_width,
@@ -1705,29 +1758,29 @@
(xmlChar *)NULL, (xmlChar *)NULL, -1);
fprintf(test->where,
"%s:create_data_socket returned %d\n",
- proc_name, s_listen);
+ __func__, s_listen);
fflush(test->where);
}
rc = bind(s_listen, my_data->locaddr->ai_addr, my_data->locaddr->ai_addrlen);
if (test->debug) {
fprintf(test->where,
"%s:bind returned %d errno=%d\n",
- proc_name, rc, errno);
+ __func__, rc, errno);
fflush(test->where);
}
if (rc == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_BIND_FAILED,
"data socket bind failed");
} else if (listen(s_listen,5) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_LISTEN_FAILED,
"data socket listen failed");
} else if (getsockname(s_listen,&myaddr,&mylen) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_GETSOCKNAME_FAILED,
"getting the listen socket name failed");
} else {
@@ -1742,30 +1795,28 @@
{
int s_data;
bsd_data_t *my_data;
- char *proc_name;
struct sockaddr peeraddr;
netperf_socklen_t peerlen;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_stream_init";
+ my_data = GET_TEST_DATA(test);
peerlen = sizeof(peeraddr);
if (test->debug) {
- fprintf(test->where, "%s:waiting in accept\n", proc_name);
+ fprintf(test->where, "%s:waiting in accept\n", __func__);
fflush(test->where);
}
if ((s_data = accept(my_data->s_listen,
&peeraddr,
&peerlen)) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_ACCEPT_FAILED,
"listen socket accept failed");
} else {
if (test->debug) {
fprintf(test->where,
"%s:accept returned successfully %d\n",
- proc_name, s_data);
+ __func__, s_data);
fflush(test->where);
}
my_data->s_data = s_data;
@@ -1779,12 +1830,10 @@
int len;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
struct sockaddr peeraddr;
netperf_socklen_t peerlen;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_rr_idle_link";
+ my_data = GET_TEST_DATA(test);
len = last_len;
peerlen = sizeof(peeraddr);
@@ -1796,12 +1845,12 @@
if (new_state == TEST_IDLE) {
if (test->debug) {
- fprintf(test->where,"%s: transition from LOAD to IDLE\n",proc_name);
+ fprintf(test->where,"%s: transition from LOAD to IDLE\n",__func__);
fflush(test->where);
}
if (shutdown(my_data->s_data,SHUT_WR) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_SOCKET_SHUTDOWN_FAILED,
"data_recv_error");
} else {
@@ -1812,21 +1861,21 @@
}
close(my_data->s_data);
if (test->debug) {
- fprintf(test->where,"%s: waiting in accept\n",proc_name);
+ fprintf(test->where,"%s: waiting in accept\n",__func__);
fflush(test->where);
}
if ((my_data->s_data=accept(my_data->s_listen,
&peeraddr,
&peerlen)) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_ACCEPT_FAILED,
"listen socket accept failed");
} else {
if (test->debug) {
fprintf(test->where,
"%s: accept returned successfully %d\n",
- proc_name,
+ __func__,
my_data->s_data);
fflush(test->where);
}
@@ -1836,7 +1885,7 @@
/* a transition to a state other than TEST_IDLE was requested
after the link was closed in the TEST_LOADED state */
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_CONNECTION_CLOSED_ERROR,
"data connection closed and non idle state requested");
}
@@ -1850,11 +1899,9 @@
char *req_ptr;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
HISTOGRAM_VARS;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_rr_meas";
+ my_data = GET_TEST_DATA(test);
/* code to timestamp enabled by WANT_HISTOGRAM */
HIST_TIMESTAMP(&time_one);
@@ -1869,7 +1916,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_RECV_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_RECV_ERROR,
"data_recv_error");
break;
@@ -1884,7 +1931,7 @@
if (len == 0) {
/* how do we deal with a closed connection in the measured state */
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_CONNECTION_CLOSED_ERROR,
"data connection closed during TEST_MEASURE state");
} else {
@@ -1896,7 +1943,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_SEND_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_SEND_ERROR,
"data_send_error");
}
@@ -1925,10 +1972,8 @@
char *req_ptr;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "recv_tcp_rr_load";
+ my_data = GET_TEST_DATA(test);
/* recv the request for the test */
req_ptr = my_data->recv_ring->buffer_ptr;
@@ -1941,7 +1986,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_RECV_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_RECV_ERROR,
"data_recv_error");
break;
@@ -1969,7 +2014,7 @@
/* this macro hides windows differences */
if (CHECK_FOR_SEND_ERROR(len)) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_SEND_ERROR,
"data_send_error");
}
@@ -1990,7 +2035,7 @@
{
bsd_data_t *my_data;
- my_data = test->test_specific_data;
+ my_data = GET_TEST_DATA(test);
my_data->recv_ring = allocate_buffer_ring(my_data->recv_width,
my_data->rsp_size,
@@ -2011,25 +2056,23 @@
send_tcp_rr_init(test_t *test)
{
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_rr_init";
+ my_data = GET_TEST_DATA(test);
if (test->debug) {
- fprintf(test->where,"%s: in INIT state making connect call\n",proc_name);
+ fprintf(test->where,"%s: in INIT state making connect call\n",__func__);
fflush(test->where);
}
if (connect(my_data->s_data,
my_data->remaddr->ai_addr,
my_data->remaddr->ai_addrlen) < 0) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_CONNECT_FAILED,
"data socket connect failed");
} else {
if (test->debug) {
- fprintf(test->where,"%s: connected and moving to IDLE\n",proc_name);
+ fprintf(test->where,"%s: connected and moving to IDLE\n",__func__);
fflush(test->where);
}
}
@@ -2042,10 +2085,8 @@
int len;
uint32_t new_state;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_rr_idle_link";
+ my_data = GET_TEST_DATA(test);
len = last_len;
new_state = CHECK_REQ_STATE;
@@ -2055,12 +2096,12 @@
}
if (new_state == TEST_IDLE) {
if (test->debug) {
- fprintf(test->where,"%s: transition from LOAD to IDLE\n",proc_name);
+ fprintf(test->where,"%s: transition from LOAD to IDLE\n",__func__);
fflush(test->where);
}
if (shutdown(my_data->s_data,SHUT_WR) == -1) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_SOCKET_SHUTDOWN_FAILED,
"failure shuting down data socket");
} else {
@@ -2072,19 +2113,19 @@
close(my_data->s_data);
my_data->s_data = create_data_socket(test);
if (test->debug) {
- fprintf(test->where,"%s: connecting from LOAD state\n",proc_name);
+ fprintf(test->where,"%s: connecting from LOAD state\n",__func__);
fflush(test->where);
}
if (connect(my_data->s_data,
my_data->remaddr->ai_addr,
my_data->remaddr->ai_addrlen) < 0) {
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_CONNECT_FAILED,
"data socket connect failed");
} else {
if (test->debug) {
- fprintf(test->where,"%s: connected moving to IDLE\n",proc_name);
+ fprintf(test->where,"%s: connected moving to IDLE\n",__func__);
fflush(test->where);
}
}
@@ -2093,7 +2134,7 @@
/* a transition to a state other than TEST_IDLE was requested
after the link was closed in the TEST_LOADED state */
report_test_failure(test,
- proc_name,
+ (char *)__func__,
BSDE_DATA_CONNECTION_CLOSED_ERROR,
"data connection closed and non idle state requested");
@@ -2108,64 +2149,66 @@
int bytes_left;
char *rsp_ptr;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_stream_meas";
- HISTOGRAM_VARS;
- /* code to make data dirty macro enabled by DIRTY */
- MAKE_DIRTY(my_data,my_data->send_ring);
- /* code to timestamp enabled by WANT_HISTOGRAM */
- HIST_TIMESTAMP(&time_one);
- /* send data for the test */
- if((len=send(my_data->s_data,
- my_data->send_ring->buffer_ptr,
- my_data->req_size,
- 0)) != my_data->req_size) {
- /* this macro hides windows differences */
- if (CHECK_FOR_SEND_ERROR(len)) {
- report_test_failure(test,
- proc_name,
- BSDE_DATA_SEND_ERROR,
- "data send error");
- }
- }
- /* recv the request for the test */
- rsp_ptr = my_data->recv_ring->buffer_ptr;
- bytes_left = my_data->rsp_size;
- while (bytes_left > 0) {
- if ((len=recv(my_data->s_data,
- rsp_ptr,
- bytes_left,
- 0)) != 0) {
+ my_data = GET_TEST_DATA(test);
+
+ while (NO_STATE_CHANGE(test)) {
+ HISTOGRAM_VARS;
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data,my_data->send_ring);
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_one);
+ /* send data for the test */
+ if((len=send(my_data->s_data,
+ my_data->send_ring->buffer_ptr,
+ my_data->req_size,
+ 0)) != my_data->req_size) {
/* this macro hides windows differences */
- if (CHECK_FOR_RECV_ERROR(len)) {
+ if (CHECK_FOR_SEND_ERROR(len)) {
report_test_failure(test,
- proc_name,
- BSDE_DATA_RECV_ERROR,
- "data_recv_error");
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data send error");
+ }
+ }
+ TCP_CHECK_BURST_SEND;
+ /* recv the request for the test */
+ rsp_ptr = my_data->recv_ring->buffer_ptr;
+ bytes_left = my_data->rsp_size;
+ while (bytes_left > 0) {
+ if ((len=recv(my_data->s_data,
+ rsp_ptr,
+ bytes_left,
+ 0)) != 0) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ rsp_ptr += len;
+ bytes_left -= len;
+ } else {
+ /* len is 0 the connection was closed exit the while loop */
break;
}
- rsp_ptr += len;
- bytes_left -= len;
- } else {
- /* len is 0 the connection was closed exit the while loop */
- break;
}
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_two);
+ HIST_ADD(my_data->time_hist,&time_one,&time_two);
+ my_data->stats.named.trans_sent++;
+ my_data->recv_ring = my_data->recv_ring->next;
+ my_data->send_ring = my_data->send_ring->next;
+ if (len == 0) {
+ /* how do we deal with a closed connection in the measured state */
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_CONNECTION_CLOSED_ERROR,
+ "data connection closed during TEST_MEASURE state");
+ }
}
- /* code to timestamp enabled by WANT_HISTOGRAM */
- HIST_TIMESTAMP(&time_two);
- HIST_ADD(my_data->time_hist,&time_one,&time_two);
- my_data->stats.named.trans_sent++;
- my_data->recv_ring = my_data->recv_ring->next;
- my_data->send_ring = my_data->send_ring->next;
- if (len == 0) {
- /* how do we deal with a closed connection in the measured state */
- report_test_failure(test,
- proc_name,
- BSDE_DATA_CONNECTION_CLOSED_ERROR,
- "data connection closed during TEST_MEASURE state");
- }
new_state = CHECK_REQ_STATE;
if (new_state == TEST_LOADED) {
/* transitioning to loaded state from measure state
@@ -2184,51 +2227,56 @@
int bytes_left;
char *rsp_ptr;
bsd_data_t *my_data;
- char *proc_name;
- my_data = test->test_specific_data;
- proc_name = "send_tcp_stream_load";
+ my_data = GET_TEST_DATA(test);
- /* code to make data dirty macro enabled by DIRTY */
- MAKE_DIRTY(my_data,my_data->send_ring);
- /* send data for the test */
- if((len=send(my_data->s_data,
- my_data->send_ring->buffer_ptr,
- my_data->req_size,
- 0)) != my_data->req_size) {
- /* this macro hides windows differences */
- if (CHECK_FOR_SEND_ERROR(len)) {
- report_test_failure(test,
- proc_name,
- BSDE_DATA_SEND_ERROR,
- "data send error");
- }
- }
- /* recv the request for the test */
- rsp_ptr = my_data->recv_ring->buffer_ptr;
- bytes_left = my_data->rsp_size;
- while (bytes_left > 0) {
- if ((len=recv(my_data->s_data,
- rsp_ptr,
- bytes_left,
- 0)) != 0) {
+ while (NO_STATE_CHANGE(test)) {
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data,my_data->send_ring);
+ /* send data for the test */
+ if((len=send(my_data->s_data,
+ my_data->send_ring->buffer_ptr,
+ my_data->req_size,
+ 0)) != my_data->req_size) {
/* this macro hides windows differences */
- if (CHECK_FOR_RECV_ERROR(len)) {
+ if (CHECK_FOR_SEND_ERROR(len)) {
report_test_failure(test,
- proc_name,
- BSDE_DATA_RECV_ERROR,
- "data_recv_error");
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data send error");
+ }
+ }
+ TCP_CHECK_BURST_SEND;
+ /* recv the request for the test */
+ rsp_ptr = my_data->recv_ring->buffer_ptr;
+ bytes_left = my_data->rsp_size;
+ while (bytes_left > 0) {
+ if ((len=recv(my_data->s_data,
+ rsp_ptr,
+ bytes_left,
+ 0)) != 0) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ rsp_ptr += len;
+ bytes_left -= len;
+ } else {
+ /* len is 0 the connection was closed exit the while loop */
break;
}
- rsp_ptr += len;
- bytes_left -= len;
- } else {
+ }
+ my_data->recv_ring = my_data->recv_ring->next;
+ my_data->send_ring = my_data->send_ring->next;
+ if (len == 0) {
/* len is 0 the connection was closed exit the while loop */
break;
}
}
- my_data->recv_ring = my_data->recv_ring->next;
- my_data->send_ring = my_data->send_ring->next;
new_state = CHECK_REQ_STATE;
if ((len == 0) ||
(new_state == TEST_IDLE)) {
@@ -2375,7 +2423,1072 @@
wait_to_die(test);
} /* end of send_tcp_rr */
+
+#define BSD_UDP_STREAM_TESTS
+#define BSD_UDP_RR_TESTS
+#ifdef BSD_UDP_STREAM_TESTS
+
+static void
+recv_udp_stream_preinit(test_t *test)
+{
+ int rc;
+ int s_data;
+ bsd_data_t *my_data;
+ struct sockaddr myaddr;
+ netperf_socklen_t mylen;
+
+ my_data = GET_TEST_DATA(test);
+ mylen = sizeof(myaddr);
+
+ my_data->recv_ring = allocate_buffer_ring(my_data->recv_width,
+ my_data->recv_size,
+ my_data->recv_align,
+ my_data->recv_offset,
+ my_data->fill_source);
+ s_data = create_data_socket(test);
+ my_data->s_data = s_data;
+ if (test->debug) {
+ dump_addrinfo(test->where, my_data->locaddr,
+ (xmlChar *)NULL, (xmlChar *)NULL, -1);
+ fprintf(test->where,
+ "%s:create_data_socket returned %d\n",
+ __func__, s_data);
+ fflush(test->where);
+ }
+ rc = bind(s_data, my_data->locaddr->ai_addr, my_data->locaddr->ai_addrlen);
+ if (test->debug) {
+ fprintf(test->where,
+ "%s:bind returned %d errno=%d\n",
+ __func__, rc, errno);
+ fflush(test->where);
+ }
+ if (rc == -1) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_BIND_FAILED,
+ "data socket bind failed");
+ } else if (getsockname(s_data,&myaddr,&mylen) == -1) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_GETSOCKNAME_FAILED,
+ "getting the data socket name failed");
+ } else {
+ memcpy(my_data->locaddr->ai_addr,&myaddr,mylen);
+ my_data->locaddr->ai_addrlen = mylen;
+ set_dependent_data(test);
+ }
+}
+
+
+static void
+recv_udp_stream_idle_link(test_t *test)
+{
+ bsd_data_t *my_data;
+ int len;
+ int ready;
+ fd_set readfds;
+ struct timeval timeout;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ FD_ZERO(&readfds);
+ timeout.tv_sec = 1;
+ timeout.tv_usec = 0;
+
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ while (ready > 0) {
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->recv_size,
+ 0,0,0)) != my_data->recv_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ }
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ }
+}
+
+static uint32_t
+recv_udp_stream_meas(test_t *test)
+{
+ int len;
+ uint32_t new_state;
+ bsd_data_t *my_data;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ while (NO_STATE_CHANGE(test)) {
+ HISTOGRAM_VARS;
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data, my_data->recv_ring);
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_one);
+ /* recv data for the test */
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->recv_size,
+ 0,0,0)) != my_data->recv_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ } else {
+ my_data->stats.named.bytes_received += len;
+ my_data->stats.named.recv_calls++;
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_two);
+ HIST_ADD(my_data->time_hist,&time_one,&time_two);
+ }
+ }
+ my_data->recv_ring = my_data->recv_ring->next;
+ }
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_LOADED) {
+ /* transitioning to loaded state from measure state
+ set current timestamp and update elapsed time */
+ gettimeofday(&(my_data->curr_time), NULL);
+ update_elapsed_time(my_data);
+ }
+ return(new_state);
+}
+
+static uint32_t
+recv_udp_stream_load(test_t *test)
+{
+ int len;
+ int ready;
+ uint32_t new_state;
+ bsd_data_t *my_data;
+ fd_set readfds;
+ struct timeval timeout;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ FD_ZERO(&readfds);
+ timeout.tv_sec = 1;
+ timeout.tv_usec = 0;
+
+ while (NO_STATE_CHANGE(test)) {
+ /* do a select call to ensure the the recvfrom will not block */
+ /* if the recvfrom blocks the test may hang on state transitions */
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ if (ready > 0) {
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data, my_data->recv_ring);
+ /* recv data for the test */
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->recv_size,
+ 0,0,0)) != my_data->recv_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ } else {
+ my_data->recv_ring = my_data->recv_ring->next;
+ }
+ }
+ }
+ }
+ /* check for state transition */
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_MEASURE) {
+ /* transitioning to measure state from loaded state
+ set previous timestamp */
+ gettimeofday(&(my_data->prev_time), NULL);
+ }
+ if (new_state == TEST_IDLE) {
+ /* a request to transition to the idle state */
+ recv_udp_stream_idle_link(test);
+ }
+ return(new_state);
+}
+
+
+static void
+send_udp_stream_preinit(test_t *test)
+{
+ bsd_data_t *my_data;
+
+ my_data = GET_TEST_DATA(test);
+
+ if (my_data->s_data == 0) {
+ my_data->send_ring = allocate_buffer_ring(my_data->send_width,
+ my_data->send_size,
+ my_data->send_align,
+ my_data->send_offset,
+ my_data->fill_source);
+ get_dependency_data(test, SOCK_DGRAM, IPPROTO_UDP);
+ my_data->s_data = create_data_socket(test);
+ } else {
+ fprintf(test->where,"entered %s more than once\n",__func__);
+ fflush(test->where);
+ }
+}
+
+
+static uint32_t
+send_udp_stream_init(test_t *test)
+{
+ int rc;
+ bsd_data_t *my_data;
+
+ my_data = GET_TEST_DATA(test);
+
+ if (test->debug) {
+ fprintf(test->where,"%s: in INIT state making bind call\n",__func__);
+ fflush(test->where);
+ }
+ rc = bind(my_data->s_data,
+ my_data->locaddr->ai_addr,
+ my_data->locaddr->ai_addrlen);
+ if (test->debug) {
+ fprintf(test->where,
+ "%s:bind returned %d errno=%d\n",
+ __func__, rc, errno);
+ fflush(test->where);
+ }
+ if (rc == -1) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_BIND_FAILED,
+ "data socket bind failed");
+ }
+ return(TEST_IDLE);
+}
+
+
+static uint32_t
+send_udp_stream_meas(test_t *test)
+{
+ int len;
+ uint32_t new_state;
+ bsd_data_t *my_data;
+
+ my_data = GET_TEST_DATA(test);
+
+ while (NO_STATE_CHANGE(test)) {
+ HISTOGRAM_VARS;
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data,my_data->send_ring);
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_one);
+ /* send data for the test */
+ if((len=sendto(my_data->s_data,
+ my_data->send_ring->buffer_ptr,
+ my_data->send_size,
+ 0,
+ my_data->remaddr->ai_addr,
+ my_data->remaddr->ai_addrlen)) != my_data->send_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_SEND_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data send error");
+ }
+ }
+ my_data->stats.named.bytes_sent += len;
+ my_data->stats.named.send_calls++;
+ my_data->send_ring = my_data->send_ring->next;
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_two);
+ HIST_ADD(my_data->time_hist,&time_one,&time_two);
+ }
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_LOADED) {
+ /* transitioning to loaded state from measure state
+ set current timestamp and update elapsed time */
+ gettimeofday(&(my_data->curr_time), NULL);
+ update_elapsed_time(my_data);
+ }
+ return(new_state);
+}
+
+
+static uint32_t
+send_udp_stream_load(test_t *test)
+{
+ int len;
+ uint32_t new_state;
+ bsd_data_t *my_data;
+
+ my_data = GET_TEST_DATA(test);
+
+ while (NO_STATE_CHANGE(test)) {
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data,my_data->send_ring);
+ /* send data for the test */
+ if((len=sendto(my_data->s_data,
+ my_data->send_ring->buffer_ptr,
+ my_data->send_size,
+ 0,
+ my_data->remaddr->ai_addr,
+ my_data->remaddr->ai_addrlen)) != my_data->send_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_SEND_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data send_error");
+ }
+ }
+ my_data->send_ring = my_data->send_ring->next;
+ }
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_MEASURE) {
+ /* transitioning to measure state from loaded state
+ set previous timestamp */
+ gettimeofday(&(my_data->prev_time), NULL);
+ }
+ return(new_state);
+}
+
+int
+recv_udp_stream_clear_stats(test_t *test)
+{
+ return(bsd_test_clear_stats(GET_TEST_DATA(test)));
+}
+
+
+xmlNodePtr
+recv_udp_stream_get_stats(test_t *test)
+{
+ return( bsd_test_get_stats(test));
+}
+
+void
+recv_udp_stream_decode_stats(xmlNodePtr stats,test_t *test)
+{
+ bsd_test_decode_stats(stats,test);
+}
+
+
+int
+send_udp_stream_clear_stats(test_t *test)
+{
+ return(bsd_test_clear_stats(GET_TEST_DATA(test)));
+}
+
+xmlNodePtr
+send_udp_stream_get_stats(test_t *test)
+{
+ return( bsd_test_get_stats(test));
+}
+
+void
+send_udp_stream_decode_stats(xmlNodePtr stats,test_t *test)
+{
+ bsd_test_decode_stats(stats,test);
+}
+
+/* This routine implements the server-side of the UDP unidirectional data */
+/* transfer test (a.k.a. stream) for the sockets interface. It receives */
+/* its parameters via the xml node contained in the test structure. */
+/* results are collected by the procedure recv_udp_stream_get_stats */
+
+void
+recv_udp_stream(test_t *test)
+{
+ uint32_t state, new_state;
+ bsd_test_init(test, SOCK_DGRAM, IPPROTO_UDP);
+ state = GET_TEST_STATE;
+ while ((state != TEST_ERROR) &&
+ (state != TEST_DEAD )) {
+ switch(state) {
+ case TEST_PREINIT:
+ recv_udp_stream_preinit(test);
+ new_state = TEST_INIT;
+ break;
+ case TEST_INIT:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ new_state = TEST_IDLE;
+ }
+ break;
+ case TEST_IDLE:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ sleep(1);
+ }
+ break;
+ case TEST_MEASURE:
+ new_state = recv_udp_stream_meas(test);
+ break;
+ case TEST_LOADED:
+ new_state = recv_udp_stream_load(test);
+ break;
+ default:
+ break;
+ } /* end of switch */
+ set_test_state(test, new_state);
+ state = GET_TEST_STATE;
+ } /* end of while */
+ wait_to_die(test);
+} /* end of recv_udp_stream */
+
+
+/* This routine implements the UDP unidirectional data transfer test */
+/* (a.k.a. stream) for the sockets interface. It receives its */
+/* parameters via the xml node contained in the test structure */
+/* output to the standard output. */
+/* results are collected by the procedure send_udp_stream_get_stats */
+
+void
+send_udp_stream(test_t *test)
+{
+ uint32_t state, new_state;
+ bsd_test_init(test, SOCK_DGRAM, IPPROTO_UDP);
+ state = GET_TEST_STATE;
+ while ((state != TEST_ERROR) &&
+ (state != TEST_DEAD )) {
+ switch(state) {
+ case TEST_PREINIT:
+ send_udp_stream_preinit(test);
+ new_state = TEST_INIT;
+ break;
+ case TEST_INIT:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ new_state = send_udp_stream_init(test);
+ }
+ break;
+ case TEST_IDLE:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ sleep(1);
+ }
+ break;
+ case TEST_MEASURE:
+ new_state = send_udp_stream_meas(test);
+ break;
+ case TEST_LOADED:
+ new_state = send_udp_stream_load(test);
+ break;
+ default:
+ break;
+ } /* end of switch */
+ set_test_state(test, new_state);
+ state = GET_TEST_STATE;
+ } /* end of while */
+ wait_to_die(test);
+} /* end of send_udp_stream */
+
+
+#endif
+/* end of BSD_UDP_STREAM_TESTS */
+#ifdef BSD_UDP_RR_TESTS
+
+static void
+recv_udp_rr_preinit(test_t *test)
+{
+ int rc;
+ int s_listen;
+ bsd_data_t *my_data;
+ struct sockaddr myaddr;
+ netperf_socklen_t mylen;
+
+ my_data = GET_TEST_DATA(test);
+ mylen = sizeof(myaddr);
+
+ my_data->recv_ring = allocate_buffer_ring(my_data->recv_width,
+ my_data->req_size,
+ my_data->recv_align,
+ my_data->recv_offset,
+ my_data->fill_source);
+ my_data->send_ring = allocate_buffer_ring(my_data->send_width,
+ my_data->rsp_size,
+ my_data->send_align,
+ my_data->send_offset,
+ my_data->fill_source);
+ s_listen = create_data_socket(test);
+ my_data->s_listen = s_listen;
+ if (test->debug) {
+ dump_addrinfo(test->where, my_data->locaddr,
+ (xmlChar *)NULL, (xmlChar *)NULL, -1);
+ fprintf(test->where,
+ "%s:create_data_socket returned %d\n",
+ __func__, s_listen);
+ fflush(test->where);
+ }
+ rc = bind(s_listen, my_data->locaddr->ai_addr, my_data->locaddr->ai_addrlen);
+ if (test->debug) {
+ fprintf(test->where,
+ "%s:bind returned %d errno=%d\n",
+ __func__, rc, errno);
+ fflush(test->where);
+ }
+ if (rc == -1) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_BIND_FAILED,
+ "data socket bind failed");
+ } else if (getsockname(s_listen,&myaddr,&mylen) == -1) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_GETSOCKNAME_FAILED,
+ "getting the data socket name failed");
+ } else {
+ memcpy(my_data->locaddr->ai_addr,&myaddr,mylen);
+ my_data->locaddr->ai_addrlen = mylen;
+ set_dependent_data(test);
+ }
+}
+
+
+static void
+recv_udp_rr_idle_link(test_t *test)
+{
+ int len;
+ bsd_data_t *my_data;
+ int ready;
+ fd_set readfds;
+ struct timeval timeout;
+
+ my_data = GET_TEST_DATA(test);
+
+ FD_ZERO(&readfds);
+ timeout.tv_sec = 1;
+ timeout.tv_usec = 0;
+
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ while (ready > 0) {
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->req_size,
+ 0,0,0)) != my_data->req_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ }
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ }
+}
+
+static uint32_t
+recv_udp_rr_meas(test_t *test)
+{
+ int len;
+ int bytes_left;
+ char *req_ptr;
+ uint32_t new_state;
+ bsd_data_t *my_data;
+ struct sockaddr peeraddr;
+ netperf_socklen_t peerlen;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ while(NO_STATE_CHANGE(test)) {
+ HISTOGRAM_VARS;
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_one);
+ /* recv the request for the test */
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->req_size,
+ 0,
+ &peeraddr,
+ &peerlen)) != my_data->req_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ my_data->stats.named.trans_received++;
+ my_data->stats.named.bytes_received += len;
+ }
+ if ((len=sendto(my_data->s_data,
+ my_data->send_ring->buffer_ptr,
+ my_data->rsp_size,
+ 0,
+ &peeraddr,
+ peerlen)) != my_data->rsp_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_SEND_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data_send_error");
+ break;
+ }
+ my_data->stats.named.bytes_sent += len;
+ }
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_two);
+ HIST_ADD(my_data->time_hist,&time_one,&time_two);
+ my_data->recv_ring = my_data->recv_ring->next;
+ my_data->send_ring = my_data->send_ring->next;
+ }
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_LOADED) {
+ /* transitioning to loaded state from measure state
+ set current timestamp and update elapsed time */
+ gettimeofday(&(my_data->curr_time), NULL);
+ update_elapsed_time(my_data);
+ }
+ return(new_state);
+}
+
+static uint32_t
+recv_udp_rr_load(test_t *test)
+{
+ int len;
+ int ready;
+ uint32_t new_state;
+ bsd_data_t *my_data;
+ struct sockaddr peeraddr;
+ netperf_socklen_t peerlen;
+ fd_set readfds;
+ struct timeval timeout;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ FD_ZERO(&readfds);
+ timeout.tv_sec = 1;
+ timeout.tv_usec = 0;
+
+ while (NO_STATE_CHANGE(test)) {
+ /* do a select call to ensure the the recvfrom will not block */
+ /* if the recvfrom blocks the test may hang on state transitions */
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ if (ready > 0) {
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->req_size,
+ 0,
+ &peeraddr,
+ &peerlen)) != my_data->req_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ }
+ /* send the response to the test */
+ if ((len=sendto(my_data->s_data,
+ my_data->send_ring->buffer_ptr,
+ my_data->rsp_size,
+ 0,
+ &peeraddr,
+ peerlen)) != my_data->rsp_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_SEND_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data_send_error");
+ }
+ break;
+ }
+ my_data->recv_ring = my_data->recv_ring->next;
+ my_data->send_ring = my_data->send_ring->next;
+ }
+ }
+ /* check for state transition */
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_MEASURE) {
+ /* transitioning to measure state from loaded state
+ set previous timestamp */
+ gettimeofday(&(my_data->prev_time), NULL);
+ }
+ if (new_state == TEST_IDLE) {
+ recv_udp_rr_idle_link(test);
+ }
+ return(new_state);
+}
+
+static void
+send_udp_rr_preinit(test_t *test)
+{
+ bsd_data_t *my_data;
+
+ my_data = GET_TEST_DATA(test);
+
+ my_data->recv_ring = allocate_buffer_ring(my_data->recv_width,
+ my_data->rsp_size,
+ my_data->recv_align,
+ my_data->recv_offset,
+ my_data->fill_source);
+ my_data->send_ring = allocate_buffer_ring(my_data->send_width,
+ my_data->req_size,
+ my_data->send_align,
+ my_data->send_offset,
+ my_data->fill_source);
+
+ get_dependency_data(test, SOCK_DGRAM, IPPROTO_UDP);
+ my_data->s_data = create_data_socket(test);
+}
+
+static uint32_t
+send_udp_rr_init(test_t *test)
+{
+ int rc;
+ bsd_data_t *my_data;
+
+ my_data = GET_TEST_DATA(test);
+
+ if (test->debug) {
+ fprintf(test->where,"%s: in INIT state making bind call\n",__func__);
+ fflush(test->where);
+ }
+ rc = bind(my_data->s_data,
+ my_data->remaddr->ai_addr,
+ my_data->remaddr->ai_addrlen);
+ if (test->debug) {
+ fprintf(test->where,
+ "%s:bind returned %d errno=%d\n",
+ __func__, rc, errno);
+ fflush(test->where);
+ }
+ if (rc == -1) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_CONNECT_FAILED,
+ "data socket connect failed");
+ }
+ /* should we add a connect here ?? */
+ return(TEST_IDLE);
+}
+
+static void
+send_udp_rr_idle_link(test_t *test)
+{
+ int len;
+ bsd_data_t *my_data;
+ int ready;
+ fd_set readfds;
+ struct timeval timeout;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ FD_ZERO(&readfds);
+ timeout.tv_sec = 1;
+ timeout.tv_usec = 0;
+
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ while (ready > 0) {
+ if ((len=recvfrom(my_data->s_data,
+ my_data->recv_ring->buffer_ptr,
+ my_data->rsp_size,
+ 0,0,0)) != my_data->rsp_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ }
+ FD_SET(my_data->s_data, &readfds);
+ ready = select(my_data->s_data+1, &readfds, NULL, NULL, &timeout);
+ }
+}
+
+static uint32_t
+send_udp_rr_meas(test_t *test)
+{
+ uint32_t new_state;
+ int len;
+ bsd_data_t *my_data;
+ char *buffer_ptr;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ while (NO_STATE_CHANGE(test)) {
+ HISTOGRAM_VARS;
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data,my_data->send_ring);
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_one);
+ /* send data for the test */
+ buffer_ptr = my_data->send_ring->buffer_ptr;
+ UDP_CHECK_FOR_RETRANS(buffer_ptr);
+ if((len=sendto(my_data->s_data,
+ buffer_ptr,
+ my_data->req_size,
+ 0,
+ my_data->remaddr->ai_addr,
+ my_data->remaddr->ai_addrlen)) != my_data->req_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_SEND_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data send error");
+ break;
+ }
+ }
+ my_data->stats.named.trans_sent++;
+ my_data->stats.named.bytes_sent += len;
+ UDP_CHECK_BURST_SEND;
+ /* recv the request for the test */
+ buffer_ptr = my_data->recv_ring->buffer_ptr;
+ if ((len=recvfrom(my_data->s_data,
+ buffer_ptr,
+ my_data->rsp_size,
+ 0,0,0)) != my_data->rsp_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ }
+ my_data->stats.named.bytes_received += len;
+ UDP_CHECK_BURST_RECV;
+ /* code to timestamp enabled by WANT_HISTOGRAM */
+ HIST_TIMESTAMP(&time_two);
+ HIST_ADD(my_data->time_hist,&time_one,&time_two);
+ my_data->send_ring = my_data->send_ring->next;
+ my_data->recv_ring = my_data->recv_ring->next;
+ }
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_LOADED) {
+ /* transitioning to loaded state from measure state
+ set current timestamp and update elapsed time */
+ gettimeofday(&(my_data->curr_time), NULL);
+ update_elapsed_time(my_data);
+ }
+ return(new_state);
+}
+
+static uint32_t
+send_udp_rr_load(test_t *test)
+{
+ uint32_t new_state;
+ int len;
+ bsd_data_t *my_data;
+ char *buffer_ptr;
+
+
+ my_data = GET_TEST_DATA(test);
+
+ while (NO_STATE_CHANGE(test)) {
+ /* code to make data dirty macro enabled by DIRTY */
+ MAKE_DIRTY(my_data,my_data->send_ring);
+ /* send data for the test */
+ buffer_ptr = my_data->send_ring->buffer_ptr;
+ UDP_CHECK_FOR_RETRANS;
+ if((len=send(my_data->s_data,
+ buffer_ptr,
+ my_data->req_size,
+ 0)) != my_data->req_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_SEND_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_SEND_ERROR,
+ "data send error");
+ break;
+ }
+ }
+ UDP_CHECK_BURST_SEND;
+ buffer_ptr = my_data->recv_ring->buffer_ptr;
+ /* recv the request for the test */
+ if ((len=recvfrom(my_data->s_data,
+ buffer_ptr,
+ my_data->rsp_size,
+ 0,0,0)) != my_data->rsp_size) {
+ /* this macro hides windows differences */
+ if (CHECK_FOR_RECV_ERROR(len)) {
+ report_test_failure(test,
+ (char *)__func__,
+ BSDE_DATA_RECV_ERROR,
+ "data_recv_error");
+ break;
+ }
+ }
+ UDP_CHECK_BURST_RECV;
+ my_data->send_ring = my_data->send_ring->next;
+ my_data->recv_ring = my_data->recv_ring->next;
+ }
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_MEASURE) {
+ /* transitioning to measure state from loaded state
+ set previous timestamp */
+ gettimeofday(&(my_data->prev_time), NULL);
+ }
+ if (new_state == TEST_IDLE) {
+ send_udp_rr_idle_link(test);
+ }
+ return(new_state);
+}
+
+int
+recv_udp_rr_clear_stats(test_t *test)
+{
+ return(bsd_test_clear_stats(GET_TEST_DATA(test)));
+}
+
+
+xmlNodePtr
+recv_udp_rr_get_stats(test_t *test)
+{
+ return( bsd_test_get_stats(test));
+}
+
+void
+recv_udp_rr_decode_stats(xmlNodePtr stats,test_t *test)
+{
+ bsd_test_decode_stats(stats,test);
+}
+
+
+int
+send_udp_rr_clear_stats(test_t *test)
+{
+ return(bsd_test_clear_stats(GET_TEST_DATA(test)));
+}
+
+xmlNodePtr
+send_udp_rr_get_stats(test_t *test)
+{
+ return( bsd_test_get_stats(test));
+}
+
+void
+send_udp_rr_decode_stats(xmlNodePtr stats,test_t *test)
+{
+ bsd_test_decode_stats(stats,test);
+}
+
+
+/* This routine implements the server-side of the TCP request/response */
+/* test (a.k.a. rr) for the sockets interface. It receives its */
+/* parameters via the xml node contained in the test structure. */
+/* results are collected by the procedure recv_udp_rr_get_stats */
+
+void
+recv_udp_rr(test_t *test)
+{
+ uint32_t state, new_state;
+ bsd_test_init(test, SOCK_DGRAM, IPPROTO_UDP);
+ state = GET_TEST_STATE;
+ while ((state != TEST_ERROR) &&
+ (state != TEST_DEAD )) {
+ switch(state) {
+ case TEST_PREINIT:
+ recv_udp_rr_preinit(test);
+ new_state = TEST_INIT;
+ break;
+ case TEST_INIT:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ new_state = TEST_IDLE;
+ }
+ break;
+ case TEST_IDLE:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ sleep(1);
+ }
+ break;
+ case TEST_MEASURE:
+ new_state = recv_udp_rr_meas(test);
+ break;
+ case TEST_LOADED:
+ new_state = recv_udp_rr_load(test);
+ break;
+ default:
+ break;
+ } /* end of switch */
+ set_test_state(test, new_state);
+ state = GET_TEST_STATE;
+ } /* end of while */
+ wait_to_die(test);
+} /* end of recv_udp_rr */
+
+
+/* This routine implements the TCP request/responce test */
+/* (a.k.a. rr) for the sockets interface. It receives its */
+/* parameters via the xml node contained in the test structure */
+/* output to the standard output. */
+/* results are collected by the procedure send_udp_rr_get_stats */
+
+void
+send_udp_rr(test_t *test)
+{
+ uint32_t state, new_state;
+ bsd_test_init(test, SOCK_DGRAM, IPPROTO_UDP);
+ state = GET_TEST_STATE;
+ while ((state != TEST_ERROR) &&
+ (state != TEST_DEAD )) {
+ switch(state) {
+ case TEST_PREINIT:
+ send_udp_rr_preinit(test);
+ new_state = TEST_INIT;
+ break;
+ case TEST_INIT:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ new_state = send_udp_rr_init(test);
+ }
+ break;
+ case TEST_IDLE:
+ new_state = CHECK_REQ_STATE;
+ if (new_state == TEST_IDLE) {
+ sleep(1);
+ }
+ break;
+ case TEST_MEASURE:
+ new_state = send_udp_rr_meas(test);
+ break;
+ case TEST_LOADED:
+ new_state = send_udp_rr_load(test);
+ break;
+ default:
+ break;
+ } /* end of switch */
+ set_test_state(test, new_state);
+ state = GET_TEST_STATE;
+ } /* end of while */
+ wait_to_die(test);
+} /* end of send_udp_rr */
+
+#endif
+/* end of BSD_UDP_STREAM_TESTS */
+
+
+
/* This implementation of report_bsd_test_results will generate strange
results if transaction count and throughput tests are included in the
same test set. The first test in the set sets the headers and algorithm
@@ -2720,7 +3833,6 @@
bsd_results_t *rd;
test_t *test;
tset_elt_t *set_elt;
- char *proc_name;
xmlNodePtr stats;
xmlNodePtr prev_stats;
int count;
@@ -2729,7 +3841,6 @@
double num_of_cpus;
rd = test_set->report_data;
- proc_name = "process_stats_for_run";
set_elt = test_set->tests;
count = test_set->confidence.count;
index = count - 1;
@@ -2742,7 +3853,7 @@
}
if (test_set->debug) {
- fprintf(test_set->where, "%s count = %d\n", proc_name, count);
+ fprintf(test_set->where, "%s count = %d\n", __func__, count);
fflush(test_set->where);
}
@@ -2804,7 +3915,7 @@
stats_for_test);
fprintf(test_set->where,
"%s was not designed to deal with this.\n",
- proc_name);
+ __func__);
fprintf(test_set->where,
"exiting netperf now!!\n");
fflush(test_set->where);
Modified: trunk/src/nettest_bsd.h
===================================================================
--- trunk/src/nettest_bsd.h 2006-05-02 22:10:46 UTC (rev 176)
+++ trunk/src/nettest_bsd.h 2006-05-17 18:30:57 UTC (rev 177)
@@ -74,7 +74,8 @@
int send_align; /* what is the alignment of the send buffer? */
int send_offset; /* and at what offset from that alignment? */
int no_delay; /* do we disable the nagle algorithm for send */
-
+ int burst_count; /* number of sends in an interval or first burst */
+ int interval; /* minimum time from start to start of bursts */
/* recv parameters */
int rbuf_size_ret; /* receive socket buffer size returned on creation */
@@ -101,6 +102,11 @@
int req_size;
int rsp_size;
+ /* data structures for UDP RR packet loss detection and retransmission. */
+ int retry_index;
+ int pending_responses;
+ char **retry_array; /* addresses of entries in the send_ring */
+
/* Statistics Counters */
union {
uint64_t counter[BSD_MAX_COUNTERS];
More information about the netperf-dev
mailing list