Google Git
Sign in
ara-mdk / platform / external / netperf / 945fbce14d217ce05aae77e10e86aacdcc5917e2 / . / nettest_sctp.c
blob: 7cfcd9fff8e5c4e5e7a91f7ca51e619b57bdfa13 [file] [log] [blame]
#ifndef lint
char nettest_sctp[]="\
@(#)nettest_sctp.c (c) Copyright 2005-2007 Hewlett-Packard Co. Version 2.4.3";
#else
#define DIRTY
#define WANT_HISTOGRAM
#define WANT_INTERVALS
#endif /* lint */
/****************************************************************/
/* */
/* nettest_sctp.c */
/* */
/* */
/* scan_sctp_args() get the sctp command line args */
/* */
/* the actual test routines... */
/* */
/* send_sctp_stream() perform a sctp stream test */
/* recv_sctp_stream() */
/* send_sctp_rr() perform a sctp request/response */
/* recv_sctp_rr() */
/* send_sctp_stream_udp() perform a sctp request/response */
/* recv_sctp_stream_upd() using UDP style API */
/* send_sctp_rr_udp() perform a sctp request/response */
/* recv_sctp_rr_upd() using UDP style API */
/* */
/* relies on create_data_socket in nettest_bsd.c */
/****************************************************************/
#if HAVE_CONFIG_H
# include <config.h>
#endif
#if defined(WANT_SCTP)
#include <sys/types.h>
#include <fcntl.h>
#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <string.h>
#include <time.h>
#ifdef NOSTDLIBH
#include <malloc.h>
#else /* NOSTDLIBH */
#include <stdlib.h>
#endif /* NOSTDLIBH */
#if !defined(__VMS)
#include <sys/ipc.h>
#endif /* !defined(__VMS) */
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <netinet/sctp.h>
#include <arpa/inet.h>
#include <netdb.h>
/* would seem that not all sctp.h files define a MSG_EOF, but that
MSG_EOF can be the same as MSG_FIN so lets work with that
assumption. initial find by Jon Pedersen. raj 2006-02-01 */
#ifndef MSG_EOF
#ifdef MSG_FIN
#define MSG_EOF MSG_FIN
#else
#error Must have either MSG_EOF or MSG_FIN defined
#endif
#endif
#include "netlib.h"
#include "netsh.h"
/* get some of the functions from nettest_bsd.c */
#include "nettest_bsd.h"
#include "nettest_sctp.h"
#ifdef WANT_HISTOGRAM
#ifdef __sgi
#include <sys/time.h>
#endif /* __sgi */
#include "hist.h"
#endif /* WANT_HISTOGRAM */
#ifdef WANT_FIRST_BURST
extern int first_burst_size;
#endif /* WANT_FIRST_BURST */
/* these variables are specific to SCTP tests. declare */
/* them static to make them global only to this file. */
static int
msg_count = 0, /* number of messages to transmit on association */
non_block = 0, /* default to blocking sockets */
num_associations = 1; /* number of associations on the endpoint */
static int confidence_iteration;
static char local_cpu_method;
static char remote_cpu_method;
#ifdef WANT_HISTOGRAM
static struct timeval time_one;
static struct timeval time_two;
static HIST time_hist;
#endif /* WANT_HISTOGRAM */
char sctp_usage[] = "\n\
Usage: netperf [global options] -- [test options] \n\
\n\
SCTP Sockets Test Options:\n\
-b number Send number requests at the start of _RR tests\n\
-D [L][,R] Set SCTP_NODELAY locally and/or remotely\n\
-h Display this text\n\
-H name,fam Use name (or IP) and family as target of data connection\n\
-L name,fam Use name (or IP) and family as source of data connextion\n\
-m bytes Set the size of each sent message\n\
-M bytes Set the size of each received messages\n\
-P local[,remote] Set the local/remote port for the data socket\n\
-r req,[rsp] Set request/response sizes (_RR tests)\n\
-s send[,recv] Set local socket send/recv buffer sizes\n\
-S send[,recv] Set remote socket send/recv buffer sizes\n\
-V Enable copy avoidance if supported\n\
-N number Specifies the number of messages to send (_STREAM tests)\n\
-B run the test in non-blocking mode\n\
-T number Number of associations to create (_MANY tests)\n\
-4 Use AF_INET (eg IPv4) on both ends of the data conn\n\
-6 Use AF_INET6 (eg IPv6) on both ends of the data conn\n\
\n\
For those options taking two parms, at least one must be specified;\n\
specifying one value without a comma will set both parms to that\n\
value, specifying a value with a leading comma will set just the second\n\
parm, a value with a trailing comma will set just the first. To set\n\
each parm to unique values, specify both and separate them with a\n\
comma.\n";
/* This routine is intended to retrieve interesting aspects of tcp */
/* for the data connection. at first, it attempts to retrieve the */
/* maximum segment size. later, it might be modified to retrieve */
/* other information, but it must be information that can be */
/* retrieved quickly as it is called during the timing of the test. */
/* for that reason, a second routine may be created that can be */
/* called outside of the timing loop */
static
void
get_sctp_info(socket, mss)
int socket;
int *mss;
{
int sock_opt_len;
if (sctp_opt_info(socket,
0,
SCTP_MAXSEG,
mss,
&sock_opt_len) < 0) {
lss_size = -1;
}
}
static
void
sctp_enable_events(socket, ev_mask)
int socket;
int ev_mask;
{
struct sctp_event_subscribe ev;
bzero(&ev, sizeof(ev));
if (ev_mask & SCTP_SNDRCV_INFO_EV)
ev.sctp_data_io_event = 1;
if (ev_mask & SCTP_ASSOC_CHANGE_EV)
ev.sctp_association_event = 1;
if (ev_mask & SCTP_PEERADDR_CHANGE_EV)
ev.sctp_address_event = 1;
if (ev_mask & SCTP_SND_FAILED_EV)
ev.sctp_send_failure_event = 1;
if (ev_mask & SCTP_REMOTE_ERROR_EV)
ev.sctp_peer_error_event = 1;
if (ev_mask & SCTP_SHUTDOWN_EV)
ev.sctp_shutdown_event = 1;
if (ev_mask & SCTP_PD_EV)
ev.sctp_partial_delivery_event = 1;
if (ev_mask & SCTP_ADAPT_EV)
#ifdef HAVE_SCTP_ADAPTATION_LAYER_EVENT
ev.sctp_adaptation_layer_event = 1;
#else
ev.sctp_adaption_layer_event = 1;
#endif
if (setsockopt(socket,
IPPROTO_SCTP,
#ifdef SCTP_EVENTS
SCTP_EVENTS,
#else
SCTP_SET_EVENTS,
#endif
(const char*)&ev,
sizeof(ev)) != 0 ) {
fprintf(where,
"sctp_enable_event: could not set sctp events errno %d\n",
errno);
fflush(where);
exit(1);
}
}
static
sctp_disposition_t
sctp_process_event(socket, buf)
int socket;
void *buf;
{
struct sctp_assoc_change *sac;
struct sctp_send_failed *ssf;
struct sctp_paddr_change *spc;
struct sctp_remote_error *sre;
union sctp_notification *snp;
snp = buf;
switch (snp->sn_header.sn_type) {
case SCTP_ASSOC_CHANGE:
if (debug) {
fprintf(where, "\tSCTP_ASSOC_CHANGE event, type:");
fflush(where);
}
sac = &snp->sn_assoc_change;
switch (sac->sac_type) {
case SCTP_COMM_UP:
if (debug) {
fprintf(where, " SCTP_COMM_UP\n");
fflush(where);
}
break;
case SCTP_RESTART:
if (debug) {
fprintf(where, " SCTP_RESTART\n");
fflush(where);
}
break;
case SCTP_CANT_STR_ASSOC:
if (debug) {
fprintf(where, " SCTP_CANT_STR_ASSOC\n");
fflush(where);
}
break; /* FIXME ignore above status changes */
case SCTP_COMM_LOST:
if (debug) {
fprintf(where, " SCTP_COMM_LOST\n");
fflush(where);
}
return SCTP_CLOSE;
case SCTP_SHUTDOWN_COMP:
if (debug) {
fprintf(where, " SCTP_SHUTDOWN_COMPLETE\n");
fflush(where);
}
return SCTP_CLOSE;
break;
}
case SCTP_SEND_FAILED:
if (debug) {
fprintf(where, "\tSCTP_SEND_FAILED event\n");
fflush(where);
}
ssf = &snp->sn_send_failed;
break; /* FIXME ??? ignore this for now */
case SCTP_PEER_ADDR_CHANGE:
if (debug) {
fprintf(where, "\tSCTP_PEER_ADDR_CHANGE event\n");
fflush(where);
}
spc = &snp->sn_paddr_change;
break; /* FIXME ??? ignore this for now */
case SCTP_REMOTE_ERROR:
if (debug) {
fprintf(where, "\tSCTP_REMOTE_ERROR event\n");
fflush(where);
}
sre = &snp->sn_remote_error;
break; /* FIXME ??? ignore this for now */
case SCTP_SHUTDOWN_EVENT:
if (debug) {
fprintf(where, "\tSCTP_SHUTDOWN event\n");
fflush(where);
}
return SCTP_CLOSE;
default:
fprintf(where, "unknown type: %hu\n", snp->sn_header.sn_type);
fflush(where);
break;
}
return SCTP_OK;
}
/* This routine implements the SCTP unidirectional data transfer test */
/* (a.k.a. stream) for the sockets interface. It receives its */
/* parameters via global variables from the shell and writes its */
/* output to the standard output. */
void
send_sctp_stream(remote_host)
char remote_host[];
{
char *tput_title = "\
Recv Send Send \n\
Socket Socket Message Elapsed \n\
Size Size Size Time Throughput \n\
bytes bytes bytes secs. %s/sec \n\n";
char *tput_fmt_0 =
"%7.2f\n";
char *tput_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f \n";
char *cpu_title = "\
Recv Send Send Utilization Service Demand\n\
Socket Socket Message Elapsed Send Recv Send Recv\n\
Size Size Size Time Throughput local remote local remote\n\
bytes bytes bytes secs. %-8.8s/s %% %c %% %c us/KB us/KB\n\n";
char *cpu_fmt_0 =
"%6.3f %c\n";
char *cpu_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f %-6.2f %-6.2f %-6.3f %-6.3f\n";
char *ksink_fmt = "\n\
Alignment Offset %-8.8s %-8.8s Sends %-8.8s Recvs\n\
Local Remote Local Remote Xfered Per Per\n\
Send Recv Send Recv Send (avg) Recv (avg)\n\
%5d %5d %5d %5d %6.4g %6.2f %6d %6.2f %6d\n";
char *ksink_fmt2 = "\n\
Maximum\n\
Segment\n\
Size (bytes)\n\
%6d\n";
float elapsed_time;
#ifdef WANT_INTERVALS
int interval_count;
sigset_t signal_set;
#endif
/* what we want is to have a buffer space that is at least one */
/* send-size greater than our send window. this will insure that we */
/* are never trying to re-use a buffer that may still be in the hands */
/* of the transport. This buffer will be malloc'd after we have found */
/* the size of the local senc socket buffer. We will want to deal */
/* with alignment and offset concerns as well. */
#ifdef DIRTY
int *message_int_ptr;
#endif
struct ring_elt *send_ring;
int len;
unsigned int nummessages = 0;
int send_socket;
int bytes_remaining;
int sctp_mss;
int timed_out;
/* with links like fddi, one can send > 32 bits worth of bytes */
/* during a test... ;-) at some point, this should probably become a */
/* 64bit integral type, but those are not entirely common yet */
double bytes_sent = 0.0;
#ifdef DIRTY
int i;
#endif /* DIRTY */
float local_cpu_utilization;
float local_service_demand;
float remote_cpu_utilization;
float remote_service_demand;
double thruput;
struct addrinfo *remote_res;
struct addrinfo *local_res;
struct addrinfo *local_remote_res;
struct addrinfo *local_local_res;
struct sctp_stream_request_struct *sctp_stream_request;
struct sctp_stream_response_struct *sctp_stream_response;
struct sctp_stream_results_struct *sctp_stream_result;
sctp_stream_request =
(struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
sctp_stream_response =
(struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
sctp_stream_result =
(struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
#ifdef WANT_HISTOGRAM
time_hist = HIST_new();
#endif /* WANT_HISTOGRAM */
/* since we are now disconnected from the code that established the */
/* control socket, and since we want to be able to use different */
/* protocols and such, we are passed the name of the remote host and */
/* must turn that into the test specific addressing information. */
/* complete_addrinfos will either succede or exit the process */
complete_addrinfos(&remote_res,
&local_res,
remote_host,
SOCK_STREAM,
IPPROTO_SCTP,
0);
if ( print_headers ) {
print_top_test_header("SCTP STREAM TEST", local_res, remote_res);
}
send_ring = NULL;
confidence_iteration = 1;
init_stat();
/* we have a great-big while loop which controls the number of times */
/* we run a particular test. this is for the calculation of a */
/* confidence interval (I really should have stayed awake during */
/* probstats :). If the user did not request confidence measurement */
/* (no confidence is the default) then we will only go though the */
/* loop once. the confidence stuff originates from the folks at IBM */
while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
(confidence_iteration <= iteration_min)) {
/* initialize a few counters. we have to remember that we might be */
/* going through the loop more than once. */
nummessages = 0;
bytes_sent = 0.0;
times_up = 0;
timed_out = 0;
/*set up the data socket */
send_socket = create_data_socket(local_res);
if (send_socket == INVALID_SOCKET){
perror("netperf: send_sctp_stream: sctp stream data socket");
exit(1);
}
if (debug) {
fprintf(where,"send_sctp_stream: send_socket obtained...\n");
}
/* at this point, we have either retrieved the socket buffer sizes, */
/* or have tried to set them, so now, we may want to set the send */
/* size based on that (because the user either did not use a -m */
/* option, or used one with an argument of 0). If the socket buffer */
/* size is not available, we will set the send size to 4KB - no */
/* particular reason, just arbitrary... */
if (send_size == 0) {
if (lss_size > 0) {
send_size = lss_size;
}
else {
send_size = 4096;
}
}
/* set-up the data buffer ring with the requested alignment and offset. */
/* note also that we have allocated a quantity */
/* of memory that is at least one send-size greater than our socket */
/* buffer size. We want to be sure that there are at least two */
/* buffers allocated - this can be a bit of a problem when the */
/* send_size is bigger than the socket size, so we must check... the */
/* user may have wanted to explicitly set the "width" of our send */
/* buffers, we should respect that wish... */
if (send_width == 0) {
send_width = (lss_size/send_size) + 1;
if (send_width == 1) send_width++;
}
if (send_ring == NULL) {
/* only allocate the send ring once. this is a networking test, */
/* not a memory allocation test. this way, we do not need a */
/* deallocate_buffer_ring() routine, and I don't feel like */
/* writing one anyway :) raj 11/94 */
send_ring = allocate_buffer_ring(send_width,
send_size,
local_send_align,
local_send_offset);
}
/* If the user has requested cpu utilization measurements, we must */
/* calibrate the cpu(s). We will perform this task within the tests */
/* themselves. If the user has specified the cpu rate, then */
/* calibrate_local_cpu will return rather quickly as it will have */
/* nothing to do. If local_cpu_rate is zero, then we will go through */
/* all the "normal" calibration stuff and return the rate back. */
if (local_cpu_usage) {
local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
}
/* Tell the remote end to do a listen. The server alters the socket */
/* paramters on the other side at this point, hence the reason for */
/* all the values being passed in the setup message. If the user did */
/* not specify any of the parameters, they will be passed as 0, which */
/* will indicate to the remote that no changes beyond the system's */
/* default should be used. Alignment is the exception, it will */
/* default to 1, which will be no alignment alterations. */
netperf_request.content.request_type = DO_SCTP_STREAM;
sctp_stream_request->send_buf_size = rss_size_req;
sctp_stream_request->recv_buf_size = rsr_size_req;
sctp_stream_request->receive_size = recv_size;
sctp_stream_request->no_delay = rem_nodelay;
sctp_stream_request->recv_alignment = remote_recv_align;
sctp_stream_request->recv_offset = remote_recv_offset;
sctp_stream_request->measure_cpu = remote_cpu_usage;
sctp_stream_request->cpu_rate = remote_cpu_rate;
if (test_time) {
sctp_stream_request->test_length = test_time;
}
else {
if (msg_count)
test_bytes = send_size * msg_count;
sctp_stream_request->test_length = test_bytes;
}
sctp_stream_request->so_rcvavoid = rem_rcvavoid;
sctp_stream_request->so_sndavoid = rem_sndavoid;
#ifdef DIRTY
sctp_stream_request->dirty_count = rem_dirty_count;
sctp_stream_request->clean_count = rem_clean_count;
#endif /* DIRTY */
sctp_stream_request->port = htonl(atoi(remote_data_port));
sctp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
sctp_stream_request->non_blocking = non_block;
if (debug > 1) {
fprintf(where,
"netperf: send_sctp_stream: requesting sctp stream test\n");
}
send_request();
/* The response from the remote will contain all of the relevant */
/* socket parameters for this test type. We will put them back into */
/* the variables here so they can be displayed if desired. The */
/* remote will have calibrated CPU if necessary, and will have done */
/* all the needed set-up we will have calibrated the cpu locally */
/* before sending the request, and will grab the counter value right*/
/* after the connect returns. The remote will grab the counter right*/
/* after the accept call. This saves the hassle of extra messages */
/* being sent for the sctp tests. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote listen done.\n");
rsr_size = sctp_stream_response->recv_buf_size;
rss_size = sctp_stream_response->send_buf_size;
rem_nodelay = sctp_stream_response->no_delay;
remote_cpu_usage= sctp_stream_response->measure_cpu;
remote_cpu_rate = sctp_stream_response->cpu_rate;
/* we have to make sure that the server port number is in */
/* network order */
set_port_number(remote_res, (short)sctp_stream_response->data_port_number);
rem_rcvavoid = sctp_stream_response->so_rcvavoid;
rem_sndavoid = sctp_stream_response->so_sndavoid;
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/*Connect up to the remote port on the data socket */
if (connect(send_socket,
remote_res->ai_addr,
remote_res->ai_addrlen) == INVALID_SOCKET) {
perror("netperf: send_sctp_stream: data socket connect failed");
exit(1);
}
sctp_enable_events(send_socket, SCTP_ASSOC_CHANGE_EV);
if (non_block) {
/* now that we are connected, mark the socket as non-blocking */
if (!set_nonblock(send_socket)) {
perror("netperf: fcntl");
exit(1);
}
}
/* Data Socket set-up is finished. If there were problems, either */
/* the connect would have failed, or the previous response would */
/* have indicated a problem. I failed to see the value of the */
/* extra message after the accept on the remote. If it failed, */
/* we'll see it here. If it didn't, we might as well start pumping */
/* data. */
/* Set-up the test end conditions. For a stream test, they can be */
/* either time or byte-count based. */
if (test_time) {
/* The user wanted to end the test after a period of time. */
times_up = 0;
bytes_remaining = 0;
/* in previous revisions, we had the same code repeated throught */
/* all the test suites. this was unnecessary, and meant more */
/* work for me when I wanted to switch to POSIX signals, so I */
/* have abstracted this out into a routine in netlib.c. if you */
/* are experiencing signal problems, you might want to look */
/* there. raj 11/94 */
start_timer(test_time);
}
else {
/* The tester wanted to send a number of bytes. */
bytes_remaining = test_bytes;
times_up = 1;
}
/* The cpu_start routine will grab the current time and possibly */
/* value of the idle counter for later use in measuring cpu */
/* utilization and/or service demand and thruput. */
cpu_start(local_cpu_usage);
#ifdef WANT_INTERVALS
if ((interval_burst) || (demo_mode)) {
/* zero means that we never pause, so we never should need the */
/* interval timer, unless we are in demo_mode */
start_itimer(interval_wate);
}
interval_count = interval_burst;
/* get the signal set for the call to sigsuspend */
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
fprintf(where,
"send_sctp_stream: unable to get sigmask errno %d\n",
errno);
fflush(where);
exit(1);
}
#endif /* WANT_INTERVALS */
#ifdef DIRTY
/* initialize the random number generator for putting dirty stuff */
/* into the send buffer. raj */
srand((int) getpid());
#endif
/* before we start, initialize a few variables */
/* We use an "OR" to control test execution. When the test is */
/* controlled by time, the byte count check will always return false. */
/* When the test is controlled by byte count, the time test will */
/* always return false. When the test is finished, the whole */
/* expression will go false and we will stop sending data. */
while ((!times_up) || (bytes_remaining > 0)) {
#ifdef DIRTY
/* we want to dirty some number of consecutive integers in the buffer */
/* we are about to send. we may also want to bring some number of */
/* them cleanly into the cache. The clean ones will follow any dirty */
/* ones into the cache. at some point, we might want to replace */
/* the rand() call with something from a table to reduce our call */
/* overhead during the test, but it is not a high priority item. */
message_int_ptr = (int *)(send_ring->buffer_ptr);
for (i = 0; i < loc_dirty_count; i++) {
*message_int_ptr = rand();
message_int_ptr++;
}
for (i = 0; i < loc_clean_count; i++) {
loc_dirty_count = *message_int_ptr;
message_int_ptr++;
}
#endif /* DIRTY */
#ifdef WANT_HISTOGRAM
/* timestamp just before we go into send and then again just after */
/* we come out raj 8/94 */
HIST_timestamp(&time_one);
#endif /* WANT_HISTOGRAM */
while ((len=sctp_sendmsg(send_socket,
send_ring->buffer_ptr, send_size,
NULL, 0,
0, 0, 0, 0, 0)) != send_size) {
if (non_block && errno == EAGAIN)
continue;
else if ((len >=0) || SOCKET_EINTR(len)) {
/* the test was interrupted, must be the end of test */
timed_out = 1;
break;
}
perror("netperf: data send error");
printf("len was %d\n",len);
exit(1);
}
if (timed_out)
break; /* we timed out durint sendmsg, done with test */
#ifdef WANT_HISTOGRAM
/* timestamp the exit from the send call and update the histogram */
HIST_timestamp(&time_two);
HIST_add(time_hist,delta_micro(&time_one,&time_two));
#endif /* WANT_HISTOGRAM */
#ifdef WANT_INTERVALS
if (demo_mode) {
units_this_tick += send_size;
}
/* in this case, the interval count is the count-down couter */
/* to decide to sleep for a little bit */
if ((interval_burst) && (--interval_count == 0)) {
/* call sigsuspend and wait for the interval timer to get us */
/* out */
if (debug > 1) {
fprintf(where,"about to suspend\n");
fflush(where);
}
if (sigsuspend(&signal_set) == EFAULT) {
fprintf(where,
"send_sctp_stream: fault with sigsuspend.\n");
fflush(where);
exit(1);
}
interval_count = interval_burst;
}
#endif /* WANT_INTERVALS */
/* now we want to move our pointer to the next position in the */
/* data buffer...we may also want to wrap back to the "beginning" */
/* of the bufferspace, so we will mod the number of messages sent */
/* by the send width, and use that to calculate the offset to add */
/* to the base pointer. */
nummessages++;
send_ring = send_ring->next;
if (bytes_remaining) {
bytes_remaining -= send_size;
}
}
/* The test is over. Flush the buffers to the remote end. We do a */
/* graceful release to insure that all data has been taken by the */
/* remote. */
/* but first, if the verbosity is greater than 1, find-out what */
/* the sctp maximum segment_size was (if possible) */
if (verbosity > 1) {
sctp_mss = -1;
get_sctp_info(send_socket, &sctp_mss);
}
shutdown(send_socket, SHUT_WR);
/* The test server will signal to us when it wants to shutdown.
* In blocking mode, we can call recvmsg. In non-blocking
* mode, we need to select on the socket for reading.
* We'll assume that all returns are succefull
*/
if (non_block) {
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(send_socket, &readfds);
select(send_socket+1, &readfds, NULL, NULL, NULL);
} else {
sctp_recvmsg(send_socket, send_ring->buffer_ptr, send_size, NULL,
0, NULL, 0);
}
/* this call will always give us the elapsed time for the test, and */
/* will also store-away the necessaries for cpu utilization */
cpu_stop(local_cpu_usage,&elapsed_time); /* was cpu being */
/* measured and how */
/* long did we really */
/* run? */
/* we are finished with the socket, so close it to prevent hitting */
/* the limit on maximum open files. */
close(send_socket);
/* Get the statistics from the remote end. The remote will have */
/* calculated service demand and all those interesting things. If it */
/* wasn't supposed to care, it will return obvious values. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote results obtained\n");
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/* We now calculate what our thruput was for the test. In the future, */
/* we may want to include a calculation of the thruput measured by */
/* the remote, but it should be the case that for a sctp stream test, */
/* that the two numbers should be *very* close... We calculate */
/* bytes_sent regardless of the way the test length was controlled. */
/* If it was time, we needed to, and if it was by bytes, the user may */
/* have specified a number of bytes that wasn't a multiple of the */
/* send_size, so we really didn't send what he asked for ;-) */
bytes_sent = ntohd(sctp_stream_result->bytes_received);
thruput = (double) calc_thruput(bytes_sent);
if (local_cpu_usage || remote_cpu_usage) {
/* We must now do a little math for service demand and cpu */
/* utilization for the system(s) */
/* Of course, some of the information might be bogus because */
/* there was no idle counter in the kernel(s). We need to make */
/* a note of this for the user's benefit...*/
if (local_cpu_usage) {
local_cpu_utilization = calc_cpu_util(0.0);
local_service_demand = calc_service_demand(bytes_sent,
0.0,
0.0,
0);
}
else {
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
}
if (remote_cpu_usage) {
remote_cpu_utilization = sctp_stream_result->cpu_util;
remote_service_demand = calc_service_demand(bytes_sent,
0.0,
remote_cpu_utilization,
sctp_stream_result->num_cpus);
}
else {
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
}
else {
/* we were not measuring cpu, for the confidence stuff, we */
/* should make it -1.0 */
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
/* at this point, we want to calculate the confidence information. */
/* if debugging is on, calculate_confidence will print-out the */
/* parameters we pass it */
calculate_confidence(confidence_iteration,
elapsed_time,
thruput,
local_cpu_utilization,
remote_cpu_utilization,
local_service_demand,
remote_service_demand);
confidence_iteration++;
}
/* at this point, we have finished making all the runs that we */
/* will be making. so, we should extract what the calcuated values */
/* are for all the confidence stuff. we could make the values */
/* global, but that seemed a little messy, and it did not seem worth */
/* all the mucking with header files. so, we create a routine much */
/* like calcualte_confidence, which just returns the mean values. */
/* raj 11/94 */
retrieve_confident_values(&elapsed_time,
&thruput,
&local_cpu_utilization,
&remote_cpu_utilization,
&local_service_demand,
&remote_service_demand);
/* We are now ready to print all the information. If the user */
/* has specified zero-level verbosity, we will just print the */
/* local service demand, or the remote service demand. If the */
/* user has requested verbosity level 1, he will get the basic */
/* "streamperf" numbers. If the user has specified a verbosity */
/* of greater than 1, we will display a veritable plethora of */
/* background information from outside of this block as it it */
/* not cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
local_cpu_method = format_cpu_method(cpu_method);
remote_cpu_method = format_cpu_method(sctp_stream_result->cpu_method);
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
format_units(),
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long was the test */
thruput, /* what was the xfer rate */
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand); /* remote service demand */
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long did it take */
thruput);/* how fast did it go */
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* sctp statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
/* this stuff needs to be worked-out in the presence of confidence */
/* intervals and multiple iterations of the test... raj 11/94 */
fprintf(where,
ksink_fmt,
"Bytes",
"Bytes",
"Bytes",
local_send_align,
remote_recv_align,
local_send_offset,
remote_recv_offset,
bytes_sent,
bytes_sent / (double)nummessages,
nummessages,
bytes_sent / (double)sctp_stream_result->recv_calls,
sctp_stream_result->recv_calls);
fprintf(where,
ksink_fmt2,
sctp_mss);
fflush(where);
#ifdef WANT_HISTOGRAM
fprintf(where,"\n\nHistogram of time spent in send() call.\n");
fflush(where);
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
}
}
/* This is the server-side routine for the sctp stream test. It is */
/* implemented as one routine. I could break things-out somewhat, but */
/* didn't feel it was necessary. */
void
recv_sctp_stream()
{
struct sockaddr_in myaddr_in; /* needed to get port number */
struct sockaddr_storage peeraddr; /* used in accept */
int s_listen,s_data;
int addrlen;
int len;
unsigned int receive_calls;
float elapsed_time;
double bytes_received;
struct ring_elt *recv_ring;
struct addrinfo *local_res;
char local_name[BUFSIZ];
char port_buffer[PORTBUFSIZE];
int msg_flags = 0;
#ifdef DIRTY
int *message_int_ptr;
int dirty_count;
int clean_count;
int i;
#endif
#ifdef DO_SELECT
fd_set readfds;
struct timeval timeout;
#endif /* DO_SELECT */
struct sctp_stream_request_struct *sctp_stream_request;
struct sctp_stream_response_struct *sctp_stream_response;
struct sctp_stream_results_struct *sctp_stream_results;
#ifdef DO_SELECT
FD_ZERO(&readfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
#endif /* DO_SELECT */
sctp_stream_request =
(struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
sctp_stream_response =
(struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
sctp_stream_results =
(struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
if (debug) {
fprintf(where,"netserver: recv_sctp_stream: entered...\n");
fflush(where);
}
/* We want to set-up the listen socket with all the desired */
/* parameters and then let the initiator know that all is ready. If */
/* socket size defaults are to be used, then the initiator will have */
/* sent us 0's. If the socket sizes cannot be changed, then we will */
/* send-back what they are. If that information cannot be determined, */
/* then we send-back -1's for the sizes. If things go wrong for any */
/* reason, we will drop back ten yards and punt. */
/* If anything goes wrong, we want the remote to know about it. It */
/* would be best if the error that the remote reports to the user is */
/* the actual error we encountered, rather than some bogus unexpected */
/* response type message. */
if (debug) {
fprintf(where,"recv_sctp_stream: setting the response type...\n");
fflush(where);
}
netperf_response.content.response_type = SCTP_STREAM_RESPONSE;
if (debug) {
fprintf(where,"recv_sctp_stream: the response type is set...\n");
fflush(where);
}
/* We now alter the message_ptr variable to be at the desired */
/* alignment with the desired offset. */
if (debug) {
fprintf(where,"recv_sctp_stream: requested alignment of %d\n",
sctp_stream_request->recv_alignment);
fflush(where);
}
/* create_data_socket expects to find some things in the global */
/* variables, so set the globals based on the values in the request. */
/* once the socket has been created, we will set the response values */
/* based on the updated value of those globals. raj 7/94 */
lss_size_req = sctp_stream_request->send_buf_size;
lsr_size_req = sctp_stream_request->recv_buf_size;
loc_nodelay = sctp_stream_request->no_delay;
loc_rcvavoid = sctp_stream_request->so_rcvavoid;
loc_sndavoid = sctp_stream_request->so_sndavoid;
non_block = sctp_stream_request->non_blocking;
set_hostname_and_port(local_name,
port_buffer,
nf_to_af(sctp_stream_request->ipfamily),
sctp_stream_request->port);
local_res = complete_addrinfo(local_name,
local_name,
port_buffer,
nf_to_af(sctp_stream_request->ipfamily),
SOCK_STREAM,
IPPROTO_SCTP,
0);
s_listen = create_data_socket(local_res);
if (s_listen < 0) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
/* what sort of sizes did we end-up with? */
if (sctp_stream_request->receive_size == 0) {
if (lsr_size > 0) {
recv_size = lsr_size;
}
else {
recv_size = 4096;
}
}
else {
recv_size = sctp_stream_request->receive_size;
}
/* we want to set-up our recv_ring in a manner analagous to what we */
/* do on the sending side. this is more for the sake of symmetry */
/* than for the needs of say copy avoidance, but it might also be */
/* more realistic - this way one could conceivably go with a */
/* double-buffering scheme when taking the data an putting it into */
/* the filesystem or something like that. raj 7/94 */
if (recv_width == 0) {
recv_width = (lsr_size/recv_size) + 1;
if (recv_width == 1) recv_width++;
}
recv_ring = allocate_buffer_ring(recv_width,
recv_size,
sctp_stream_request->recv_alignment,
sctp_stream_request->recv_offset);
if (debug) {
fprintf(where,"recv_sctp_stream: set recv_size = %d, align = %d, offset = %d.\n",
recv_size, sctp_stream_request->recv_alignment,
sctp_stream_request->recv_offset);
fflush(where);
}
/* now get the port number assigned by the system */
addrlen = sizeof(myaddr_in);
if (getsockname(s_listen,
(struct sockaddr *)&myaddr_in,
&addrlen) == -1){
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
exit(1);
}
/* Now myaddr_in contains the port and the internet address this is */
/* returned to the sender also implicitly telling the sender that the */
/* socket buffer sizing has been done. */
sctp_stream_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
netperf_response.content.serv_errno = 0;
/* But wait, there's more. If the initiator wanted cpu measurements, */
/* then we must call the calibrate routine, which will return the max */
/* rate back to the initiator. If the CPU was not to be measured, or */
/* something went wrong with the calibration, we will return a -1 to */
/* the initiator. */
sctp_stream_response->cpu_rate = (float)0.0; /* assume no cpu */
if (sctp_stream_request->measure_cpu) {
sctp_stream_response->measure_cpu = 1;
sctp_stream_response->cpu_rate =
calibrate_local_cpu(sctp_stream_request->cpu_rate);
}
else {
sctp_stream_response->measure_cpu = 0;
}
/* before we send the response back to the initiator, pull some of */
/* the socket parms from the globals */
sctp_stream_response->send_buf_size = lss_size;
sctp_stream_response->recv_buf_size = lsr_size;
sctp_stream_response->no_delay = loc_nodelay;
sctp_stream_response->so_rcvavoid = loc_rcvavoid;
sctp_stream_response->so_sndavoid = loc_sndavoid;
sctp_stream_response->receive_size = recv_size;
/* Now, let's set-up the socket to listen for connections */
if (listen(s_listen, 5) == -1) {
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
exit(1);
}
send_response();
addrlen = sizeof(peeraddr);
if ((s_data = accept(s_listen,
(struct sockaddr *)&peeraddr,
&addrlen)) == INVALID_SOCKET) {
/* Let's just punt. The remote will be given some information */
close(s_listen);
exit(1);
}
sctp_enable_events(s_data, SCTP_ASSOC_CHANGE_EV | SCTP_SHUTDOWN_EV);
/* now that we are connected, mark the socket as non-blocking */
if (non_block) {
fprintf(where, "setting socket as nonblocking\n");
fflush(where);
if (!set_nonblock(s_data)) {
close(s_data);
exit(1);
}
}
#ifdef KLUDGE_SOCKET_OPTIONS
/* this is for those systems which *INCORRECTLY* fail to pass */
/* attributes across an accept() call. Including this goes against */
/* my better judgement :( raj 11/95 */
kludge_socket_options(s_data);
#endif /* KLUDGE_SOCKET_OPTIONS */
/* Now it's time to start receiving data on the connection. We will */
/* first grab the apropriate counters and then start grabbing. */
cpu_start(sctp_stream_request->measure_cpu);
/* The loop will exit when the sender does a shutdown, which will */
/* return a length of zero */
#ifdef DIRTY
/* we want to dirty some number of consecutive integers in the buffer */
/* we are about to recv. we may also want to bring some number of */
/* them cleanly into the cache. The clean ones will follow any dirty */
/* ones into the cache. */
dirty_count = sctp_stream_request->dirty_count;
clean_count = sctp_stream_request->clean_count;
message_int_ptr = (int *)recv_ring->buffer_ptr;
for (i = 0; i < dirty_count; i++) {
*message_int_ptr = rand();
message_int_ptr++;
}
for (i = 0; i < clean_count; i++) {
dirty_count = *message_int_ptr;
message_int_ptr++;
}
#endif /* DIRTY */
bytes_received = 0;
receive_calls = 0;
while ((len = sctp_recvmsg(s_data,
recv_ring->buffer_ptr, recv_size,
NULL, 0, NULL, &msg_flags)) != 0) {
if (len == SOCKET_ERROR) {
if (non_block && errno == EAGAIN) {
if (debug){
fprintf(where,
"recv_sctp_stream: sctp_recvmsg timed out, trying again\n");
fflush(where);
}
Set_errno(0);
continue;
}
if (debug) {
fprintf(where,
"recv_sctp_stream: sctp_recvmsg error %d, exiting",
errno);
fflush(where);
}
netperf_response.content.serv_errno = errno;
send_response();
close(s_data);
exit(1);
}
if (msg_flags & MSG_NOTIFICATION) {
msg_flags = 0;
if (debug) {
fprintf(where,
"recv_sctp_stream: Got notification... processing\n");
fflush(where);
}
if (sctp_process_event(s_data, recv_ring->buffer_ptr) == SCTP_CLOSE)
break; /* break out of the recvmsg loop */
continue;
}
bytes_received += len;
receive_calls++;
/* more to the next buffer in the recv_ring */
recv_ring = recv_ring->next;
#ifdef PAUSE
sleep(1);
#endif /* PAUSE */
#ifdef DIRTY
message_int_ptr = (int *)(recv_ring->buffer_ptr);
for (i = 0; i < dirty_count; i++) {
*message_int_ptr = rand();
message_int_ptr++;
}
for (i = 0; i < clean_count; i++) {
dirty_count = *message_int_ptr;
message_int_ptr++;
}
#endif /* DIRTY */
#ifdef DO_SELECT
FD_SET(s_data,&readfds);
select(s_data+1,&readfds,NULL,NULL,&timeout);
#endif /* DO_SELECT */
}
/* perform a shutdown to signal the sender that */
/* we have received all the data sent. raj 4/93 */
if (close(s_data) == -1) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
cpu_stop(sctp_stream_request->measure_cpu,&elapsed_time);
/* send the results to the sender */
if (debug) {
fprintf(where,
"recv_sctp_stream: got %g bytes\n",
bytes_received);
fprintf(where,
"recv_sctp_stream: got %d recvs\n",
receive_calls);
fflush(where);
}
sctp_stream_results->bytes_received = htond(bytes_received);
sctp_stream_results->elapsed_time = elapsed_time;
sctp_stream_results->recv_calls = receive_calls;
if (sctp_stream_request->measure_cpu) {
sctp_stream_results->cpu_util = calc_cpu_util(0.0);
};
if (debug) {
fprintf(where,
"recv_sctp_stream: test complete, sending results.\n");
fprintf(where,
" bytes_received %g receive_calls %d\n",
bytes_received,
receive_calls);
fprintf(where,
" len %d\n",
len);
fflush(where);
}
sctp_stream_results->cpu_method = cpu_method;
sctp_stream_results->num_cpus = lib_num_loc_cpus;
send_response();
/* we are now done with the sockets */
close(s_listen);
}
/* This routine implements the SCTP unidirectional data transfer test */
/* (a.k.a. stream) for the sockets interface. It receives its */
/* parameters via global variables from the shell and writes its */
/* output to the standard output. */
void
send_sctp_stream_1toMany(remote_host)
char remote_host[];
{
char *tput_title = "\
Recv Send Send \n\
Socket Socket Message Elapsed \n\
Size Size Size Time Throughput \n\
bytes bytes bytes secs. %s/sec \n\n";
char *tput_fmt_0 =
"%7.2f\n";
char *tput_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f \n";
char *cpu_title = "\
Recv Send Send Utilization Service Demand\n\
Socket Socket Message Elapsed Send Recv Send Recv\n\
Size Size Size Time Throughput local remote local remote\n\
bytes bytes bytes secs. %-8.8s/s %% %c %% %c us/KB us/KB\n\n";
char *cpu_fmt_0 =
"%6.3f %c\n";
char *cpu_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f %-6.2f %-6.2f %-6.3f %-6.3f\n";
char *ksink_fmt = "\n\
Alignment Offset %-8.8s %-8.8s Sends %-8.8s Recvs\n\
Local Remote Local Remote Xfered Per Per\n\
Send Recv Send Recv Send (avg) Recv (avg)\n\
%5d %5d %5d %5d %6.4g %6.2f %6d %6.2f %6d\n";
char *ksink_fmt2 = "\n\
Maximum\n\
Segment\n\
Size (bytes)\n\
%6d\n";
float elapsed_time;
#ifdef WANT_INTERVALS
int interval_count;
sigset_t signal_set;
#endif
/* what we want is to have a buffer space that is at least one */
/* send-size greater than our send window. this will insure that we */
/* are never trying to re-use a buffer that may still be in the hands */
/* of the transport. This buffer will be malloc'd after we have found */
/* the size of the local senc socket buffer. We will want to deal */
/* with alignment and offset concerns as well. */
#ifdef DIRTY
int *message_int_ptr;
#endif
struct ring_elt *send_ring;
int len;
unsigned int nummessages = 0;
int *send_socket;
int bytes_remaining;
int sctp_mss;
/* with links like fddi, one can send > 32 bits worth of bytes */
/* during a test... ;-) at some point, this should probably become a */
/* 64bit integral type, but those are not entirely common yet */
double bytes_sent = 0.0;
#ifdef DIRTY
int i;
#endif /* DIRTY */
int j;
float local_cpu_utilization;
float local_service_demand;
float remote_cpu_utilization;
float remote_service_demand;
double thruput;
struct addrinfo *remote_res;
struct addrinfo *local_res;
struct addrinfo *last_remote_res;
struct addrinfo *last_local_res;
struct sctp_stream_request_struct *sctp_stream_request;
struct sctp_stream_response_struct *sctp_stream_response;
struct sctp_stream_results_struct *sctp_stream_result;
sctp_stream_request =
(struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
sctp_stream_response =
(struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
sctp_stream_result =
(struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
#ifdef WANT_HISTOGRAM
time_hist = HIST_new();
#endif /* WANT_HISTOGRAM */
complete_addrinfos(&remote_res,
&local_res,
remote_host,
SOCK_SEQPACKET,
IPPROTO_SCTP,
0);
if ( print_headers ) {
print_top_test_header("SCTP 1-TO-MANY STREAM TEST",local_res,remote_res);
}
send_ring = NULL;
confidence_iteration = 1;
init_stat();
send_socket = malloc(sizeof (int) * num_associations);
if (send_socket == NULL) {
fprintf(where, "send_sctp_stream_1toMany: failed to allocation sockets!\n");
exit(1);
}
/* we have a great-big while loop which controls the number of times */
/* we run a particular test. this is for the calculation of a */
/* confidence interval (I really should have stayed awake during */
/* probstats :). If the user did not request confidence measurement */
/* (no confidence is the default) then we will only go though the */
/* loop once. the confidence stuff originates from the folks at IBM */
while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
(confidence_iteration <= iteration_min)) {
int j=0;
int timed_out = 0;
/* initialize a few counters. we have to remember that we might be */
/* going through the loop more than once. */
nummessages = 0;
bytes_sent = 0.0;
times_up = 0;
/* at this point, we have either retrieved the socket buffer sizes, */
/* or have tried to set them, so now, we may want to set the send */
/* size based on that (because the user either did not use a -m */
/* option, or used one with an argument of 0). If the socket buffer */
/* size is not available, we will set the send size to 4KB - no */
/* particular reason, just arbitrary... */
if (send_size == 0) {
if (lss_size > 0) {
send_size = lss_size;
}
else {
send_size = 4096;
}
}
/* set-up the data buffer ring with the requested alignment and offset. */
/* note also that we have allocated a quantity */
/* of memory that is at least one send-size greater than our socket */
/* buffer size. We want to be sure that there are at least two */
/* buffers allocated - this can be a bit of a problem when the */
/* send_size is bigger than the socket size, so we must check... the */
/* user may have wanted to explicitly set the "width" of our send */
/* buffers, we should respect that wish... */
if (send_width == 0) {
send_width = (lss_size/send_size) + 1;
if (send_width == 1) send_width++;
}
if (send_ring == NULL) {
/* only allocate the send ring once. this is a networking test, */
/* not a memory allocation test. this way, we do not need a */
/* deallocate_buffer_ring() routine, and I don't feel like */
/* writing one anyway :) raj 11/94 */
send_ring = allocate_buffer_ring(send_width,
send_size,
local_send_align,
local_send_offset);
}
/* If the user has requested cpu utilization measurements, we must */
/* calibrate the cpu(s). We will perform this task within the tests */
/* themselves. If the user has specified the cpu rate, then */
/* calibrate_local_cpu will return rather quickly as it will have */
/* nothing to do. If local_cpu_rate is zero, then we will go through */
/* all the "normal" calibration stuff and return the rate back. */
if (local_cpu_usage) {
local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
}
/* Tell the remote end to do a listen. The server alters the socket */
/* paramters on the other side at this point, hence the reason for */
/* all the values being passed in the setup message. If the user did */
/* not specify any of the parameters, they will be passed as 0, which */
/* will indicate to the remote that no changes beyond the system's */
/* default should be used. Alignment is the exception, it will */
/* default to 1, which will be no alignment alterations. */
netperf_request.content.request_type = DO_SCTP_STREAM_MANY;
sctp_stream_request->send_buf_size = rss_size_req;
sctp_stream_request->recv_buf_size = rsr_size_req;
sctp_stream_request->receive_size = recv_size;
sctp_stream_request->no_delay = rem_nodelay;
sctp_stream_request->recv_alignment = remote_recv_align;
sctp_stream_request->recv_offset = remote_recv_offset;
sctp_stream_request->measure_cpu = remote_cpu_usage;
sctp_stream_request->cpu_rate = remote_cpu_rate;
if (test_time) {
sctp_stream_request->test_length = test_time;
}
else {
if (msg_count)
test_bytes = send_size * msg_count;
sctp_stream_request->test_length = test_bytes*num_associations;
}
sctp_stream_request->so_rcvavoid = rem_rcvavoid;
sctp_stream_request->so_sndavoid = rem_sndavoid;
#ifdef DIRTY
sctp_stream_request->dirty_count = rem_dirty_count;
sctp_stream_request->clean_count = rem_clean_count;
#endif /* DIRTY */
sctp_stream_request->port = (atoi(remote_data_port));
sctp_stream_request->ipfamily = af_to_nf(remote_res->ai_family);
sctp_stream_request->non_blocking = non_block;
if (debug > 1) {
fprintf(where,
"netperf: send_sctp_stream_1toMany: requesting sctp stream test\n");
}
send_request();
/* The response from the remote will contain all of the relevant */
/* socket parameters for this test type. We will put them back into */
/* the variables here so they can be displayed if desired. The */
/* remote will have calibrated CPU if necessary, and will have done */
/* all the needed set-up we will have calibrated the cpu locally */
/* before sending the request, and will grab the counter value right*/
/* after the connect returns. The remote will grab the counter right*/
/* after the accept call. This saves the hassle of extra messages */
/* being sent for the sctp tests. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote listen done.\n");
rsr_size = sctp_stream_response->recv_buf_size;
rss_size = sctp_stream_response->send_buf_size;
rem_nodelay = sctp_stream_response->no_delay;
remote_cpu_usage= sctp_stream_response->measure_cpu;
remote_cpu_rate = sctp_stream_response->cpu_rate;
/* we have to make sure that the server port number is in */
/* network order */
set_port_number(remote_res, (unsigned short)sctp_stream_response->data_port_number);
rem_rcvavoid = sctp_stream_response->so_rcvavoid;
rem_sndavoid = sctp_stream_response->so_sndavoid;
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/*set up the the array of data sockets and connect them to the server */
for (j = 0; j < num_associations; j++) {
send_socket[j] = create_data_socket(local_res);
if (send_socket[j] < 0){
perror("netperf: send_sctp_stream_1toMany: sctp stream data socket");
exit(1);
}
if (debug) {
fprintf(where,"send_sctp_stream_1toMany: send_socket obtained...\n");
}
/*Connect up to the remote port on the data socket */
if (connect(send_socket[j],
remote_res->ai_addr,
remote_res->ai_addrlen) == INVALID_SOCKET){
perror("netperf: send_sctp_stream_1toMany: data socket connect failed");
exit(1);
}
/* Do it after connect is successfull, so that we don't see COMM_UP */
sctp_enable_events(send_socket[j], SCTP_ASSOC_CHANGE_EV);
if (non_block) {
/* now that we are connected, mark the socket as non-blocking */
if (!set_nonblock(send_socket[j])) {
perror("netperf: fcntl");
exit(1);
}
}
}
/* Data Socket set-up is finished. If there were problems, either */
/* the connect would have failed, or the previous response would */
/* have indicated a problem. I failed to see the value of the */
/* extra message after the accept on the remote. If it failed, */
/* we'll see it here. If it didn't, we might as well start pumping */
/* data. */
/* Set-up the test end conditions. For a stream test, they can be */
/* either time or byte-count based. */
if (test_time) {
/* The user wanted to end the test after a period of time. */
times_up = 0;
bytes_remaining = 0;
/* in previous revisions, we had the same code repeated throught */
/* all the test suites. this was unnecessary, and meant more */
/* work for me when I wanted to switch to POSIX signals, so I */
/* have abstracted this out into a routine in netlib.c. if you */
/* are experiencing signal problems, you might want to look */
/* there. raj 11/94 */
start_timer(test_time);
}
else {
/* The tester wanted to send a number of bytes. */
bytes_remaining = test_bytes * num_associations;
times_up = 1;
}
/* The cpu_start routine will grab the current time and possibly */
/* value of the idle counter for later use in measuring cpu */
/* utilization and/or service demand and thruput. */
cpu_start(local_cpu_usage);
#ifdef WANT_INTERVALS
if ((interval_burst) || (demo_mode)) {
/* zero means that we never pause, so we never should need the */
/* interval timer, unless we are in demo_mode */
start_itimer(interval_wate);
}
interval_count = interval_burst;
/* get the signal set for the call to sigsuspend */
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
fprintf(where,
"send_sctp_stream_1toMany: unable to get sigmask errno %d\n",
errno);
fflush(where);
exit(1);
}
#endif /* WANT_INTERVALS */
#ifdef DIRTY
/* initialize the random number generator for putting dirty stuff */
/* into the send buffer. raj */
srand((int) getpid());
#endif
/* before we start, initialize a few variables */
/* We use an "OR" to control test execution. When the test is */
/* controlled by time, the byte count check will always return false. */
/* When the test is controlled by byte count, the time test will */
/* always return false. When the test is finished, the whole */
/* expression will go false and we will stop sending data. */
while ((!times_up) || (bytes_remaining > 0)) {
#ifdef DIRTY
/* we want to dirty some number of consecutive integers in the buffer */
/* we are about to send. we may also want to bring some number of */
/* them cleanly into the cache. The clean ones will follow any dirty */
/* ones into the cache. at some point, we might want to replace */
/* the rand() call with something from a table to reduce our call */
/* overhead during the test, but it is not a high priority item. */
message_int_ptr = (int *)(send_ring->buffer_ptr);
for (i = 0; i < loc_dirty_count; i++) {
*message_int_ptr = rand();
message_int_ptr++;
}
for (i = 0; i < loc_clean_count; i++) {
loc_dirty_count = *message_int_ptr;
message_int_ptr++;
}
#endif /* DIRTY */
#ifdef WANT_HISTOGRAM
/* timestamp just before we go into send and then again just after */
/* we come out raj 8/94 */
gettimeofday(&time_one,NULL);
#endif /* WANT_HISTOGRAM */
for (j = 0; j < num_associations; j++) {
if((len=sctp_sendmsg(send_socket[j],
send_ring->buffer_ptr,
send_size,
(struct sockaddr *)remote_res->ai_addr,
remote_res->ai_addrlen,
0, 0, 0, 0, 0)) != send_size) {
if ((len >=0) || SOCKET_EINTR(len)) {
/* the test was interrupted, must be the end of test */
timed_out = 1;
break;
} else if (non_block && errno == EAGAIN) {
j--; /* send again on the same socket */
Set_errno(0);
continue;
}
perror("netperf: data send error");
printf("len was %d\n",len);
exit(1);
}
}
if (timed_out)
break; /* test is over, try next iteration */
#ifdef WANT_HISTOGRAM
/* timestamp the exit from the send call and update the histogram */
gettimeofday(&time_two,NULL);
HIST_add(time_hist,delta_micro(&time_one,&time_two));
#endif /* WANT_HISTOGRAM */
#ifdef WANT_INTERVALS
if (demo_mode) {
units_this_tick += send_size;
}
/* in this case, the interval count is the count-down couter */
/* to decide to sleep for a little bit */
if ((interval_burst) && (--interval_count == 0)) {
/* call sigsuspend and wait for the interval timer to get us */
/* out */
if (debug > 1) {
fprintf(where,"about to suspend\n");
fflush(where);
}
if (sigsuspend(&signal_set) == EFAULT) {
fprintf(where,
"send_sctp_stream_1toMany: fault with sigsuspend.\n");
fflush(where);
exit(1);
}
interval_count = interval_burst;
}
#endif /* WANT_INTERVALS */
/* now we want to move our pointer to the next position in the */
/* data buffer...we may also want to wrap back to the "beginning" */
/* of the bufferspace, so we will mod the number of messages sent */
/* by the send width, and use that to calculate the offset to add */
/* to the base pointer. */
nummessages++;
send_ring = send_ring->next;
if (bytes_remaining) {
bytes_remaining -= send_size;
}
}
/* The test is over. Flush the buffers to the remote end. We do a */
/* graceful release to insure that all data has been taken by the */
/* remote. */
/* but first, if the verbosity is greater than 1, find-out what */
/* the sctp maximum segment_size was (if possible) */
if (verbosity > 1) {
sctp_mss = -1;
get_sctp_info(send_socket[0], &sctp_mss);
}
/* signal the server that we are all done writing, this will
* initiate a shutdonw of one of the associations on the
* server and trigger an event telling the server it's all done
*/
sctp_sendmsg(send_socket[0], NULL, 0, remote_res->ai_addr,
remote_res->ai_addrlen, 0, MSG_EOF, 0, 0, 0);
/* The test server will initiate closure of all associations
* when it's done reading. We want a basic mechanism to catch this
* and are using SCTP events for this.
* In blocking mode, we can call recvmsg with the last socket we created.
* In non-blocking mode, we need to select on the socket for reading.
* We'll assume that all returns are succefull and signify
* closure.
* It is sufficient to do this on a single socket in the client.
* We choose to do it on a socket other then the one that send MSG_EOF.
* This means that anything comming in on that socket will be a shutdown.
*/
if (non_block) {
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(send_socket[num_associations-1], &readfds);
select(send_socket[num_associations-1]+1, &readfds, NULL, NULL, NULL);
} else {
sctp_recvmsg(send_socket[num_associations], send_ring->buffer_ptr,
send_size, NULL, 0, NULL, 0);
}
/* this call will always give us the elapsed time for the test, and */
/* will also store-away the necessaries for cpu utilization */
cpu_stop(local_cpu_usage,&elapsed_time); /* was cpu being */
/* measured and how */
/* long did we really */
/* run? */
/* we are finished with our sockets, so close them to prevent hitting */
/* the limit on maximum open files. */
for (j = 0; j < num_associations; j++)
close(send_socket[j]);
/* Get the statistics from the remote end. The remote will have */
/* calculated service demand and all those interesting things. If it */
/* wasn't supposed to care, it will return obvious values. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote results obtained\n");
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/* We now calculate what our thruput was for the test. In the future, */
/* we may want to include a calculation of the thruput measured by */
/* the remote, but it should be the case that for a sctp stream test, */
/* that the two numbers should be *very* close... We calculate */
/* bytes_sent regardless of the way the test length was controlled. */
/* If it was time, we needed to, and if it was by bytes, the user may */
/* have specified a number of bytes that wasn't a multiple of the */
/* send_size, so we really didn't send what he asked for ;-) */
bytes_sent = ntohd(sctp_stream_result->bytes_received);
thruput = (double) calc_thruput(bytes_sent);
if (local_cpu_usage || remote_cpu_usage) {
/* We must now do a little math for service demand and cpu */
/* utilization for the system(s) */
/* Of course, some of the information might be bogus because */
/* there was no idle counter in the kernel(s). We need to make */
/* a note of this for the user's benefit...*/
if (local_cpu_usage) {
local_cpu_utilization = calc_cpu_util(0.0);
local_service_demand = calc_service_demand(bytes_sent,
0.0,
0.0,
0);
}
else {
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
}
if (remote_cpu_usage) {
remote_cpu_utilization = sctp_stream_result->cpu_util;
remote_service_demand = calc_service_demand(bytes_sent,
0.0,
remote_cpu_utilization,
sctp_stream_result->num_cpus);
}
else {
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
}
else {
/* we were not measuring cpu, for the confidence stuff, we */
/* should make it -1.0 */
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
/* at this point, we want to calculate the confidence information. */
/* if debugging is on, calculate_confidence will print-out the */
/* parameters we pass it */
calculate_confidence(confidence_iteration,
elapsed_time,
thruput,
local_cpu_utilization,
remote_cpu_utilization,
local_service_demand,
remote_service_demand);
confidence_iteration++;
}
/* at this point, we have finished making all the runs that we */
/* will be making. so, we should extract what the calcuated values */
/* are for all the confidence stuff. we could make the values */
/* global, but that seemed a little messy, and it did not seem worth */
/* all the mucking with header files. so, we create a routine much */
/* like calcualte_confidence, which just returns the mean values. */
/* raj 11/94 */
retrieve_confident_values(&elapsed_time,
&thruput,
&local_cpu_utilization,
&remote_cpu_utilization,
&local_service_demand,
&remote_service_demand);
/* We are now ready to print all the information. If the user */
/* has specified zero-level verbosity, we will just print the */
/* local service demand, or the remote service demand. If the */
/* user has requested verbosity level 1, he will get the basic */
/* "streamperf" numbers. If the user has specified a verbosity */
/* of greater than 1, we will display a veritable plethora of */
/* background information from outside of this block as it it */
/* not cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
local_cpu_method = format_cpu_method(cpu_method);
remote_cpu_method = format_cpu_method(sctp_stream_result->cpu_method);
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
format_units(),
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long was the test */
thruput, /* what was the xfer rate */
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand); /* remote service demand */
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long did it take */
thruput);/* how fast did it go */
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* sctp statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
/* this stuff needs to be worked-out in the presence of confidence */
/* intervals and multiple iterations of the test... raj 11/94 */
fprintf(where,
ksink_fmt,
"Bytes",
"Bytes",
"Bytes",
local_send_align,
remote_recv_align,
local_send_offset,
remote_recv_offset,
bytes_sent,
bytes_sent / (double)nummessages,
nummessages,
bytes_sent / (double)sctp_stream_result->recv_calls,
sctp_stream_result->recv_calls);
fprintf(where,
ksink_fmt2,
sctp_mss);
fflush(where);
#ifdef WANT_HISTOGRAM
fprintf(where,"\n\nHistogram of time spent in send() call.\n");
fflush(where);
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
}
}
/* This is the server-side routine for the sctp stream test. It is */
/* implemented as one routine. I could break things-out somewhat, but */
/* didn't feel it was necessary. */
void
recv_sctp_stream_1toMany()
{
struct sockaddr_in myaddr_in;
int s_recv;
int addrlen;
int len;
unsigned int receive_calls;
float elapsed_time;
double bytes_received;
int msg_flags = 0;
struct ring_elt *recv_ring;
struct addrinfo *local_res;
char local_name[BUFSIZ];
char port_buffer[PORTBUFSIZE];
#ifdef DIRTY
int *message_int_ptr;
int dirty_count;
int clean_count;
int i;
#endif
#ifdef DO_SELECT
fd_set readfds;
struct timeval timeout;
#endif
struct sctp_stream_request_struct *sctp_stream_request;
struct sctp_stream_response_struct *sctp_stream_response;
struct sctp_stream_results_struct *sctp_stream_results;
#ifdef DO_SELECT
FD_ZERO(&readfds);
timeout.tv_sec = 1;
timeout.tv_usec = 0;
#endif
sctp_stream_request =
(struct sctp_stream_request_struct *)netperf_request.content.test_specific_data;
sctp_stream_response =
(struct sctp_stream_response_struct *)netperf_response.content.test_specific_data;
sctp_stream_results =
(struct sctp_stream_results_struct *)netperf_response.content.test_specific_data;
if (debug) {
fprintf(where,"netserver: recv_sctp_stream: entered...\n");
fflush(where);
}
/* We want to set-up the listen socket with all the desired */
/* parameters and then let the initiator know that all is ready. If */
/* socket size defaults are to be used, then the initiator will have */
/* sent us 0's. If the socket sizes cannot be changed, then we will */
/* send-back what they are. If that information cannot be determined, */
/* then we send-back -1's for the sizes. If things go wrong for any */
/* reason, we will drop back ten yards and punt. */
/* If anything goes wrong, we want the remote to know about it. It */
/* would be best if the error that the remote reports to the user is */
/* the actual error we encountered, rather than some bogus unexpected */
/* response type message. */
if (debug) {
fprintf(where,"recv_sctp_stream_1toMany: setting the response type...\n");
fflush(where);
}
netperf_response.content.response_type = SCTP_STREAM_MANY_RESPONSE;
if (debug) {
fprintf(where,"recv_sctp_stream_1toMany: the response type is set...\n");
fflush(where);
}
/* We now alter the message_ptr variable to be at the desired */
/* alignment with the desired offset. */
if (debug) {
fprintf(where,"recv_sctp_stream_1toMany: requested alignment of %d\n",
sctp_stream_request->recv_alignment);
fflush(where);
}
/* create_data_socket expects to find some things in the global */
/* variables, so set the globals based on the values in the request. */
/* once the socket has been created, we will set the response values */
/* based on the updated value of those globals. raj 7/94 */
lss_size_req = sctp_stream_request->send_buf_size;
lsr_size_req = sctp_stream_request->recv_buf_size;
loc_nodelay = sctp_stream_request->no_delay;
loc_rcvavoid = sctp_stream_request->so_rcvavoid;
loc_sndavoid = sctp_stream_request->so_sndavoid;
non_block = sctp_stream_request->non_blocking;
set_hostname_and_port(local_name,
port_buffer,
nf_to_af(sctp_stream_request->ipfamily),
sctp_stream_request->port);
local_res = complete_addrinfo(local_name,
local_name,
port_buffer,
nf_to_af(sctp_stream_request->ipfamily),
SOCK_SEQPACKET,
IPPROTO_SCTP,
0);
s_recv = create_data_socket(local_res);
if (s_recv < 0) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
/* what sort of sizes did we end-up with? */
if (sctp_stream_request->receive_size == 0) {
if (lsr_size > 0) {
recv_size = lsr_size;
}
else {
recv_size = 4096;
}
}
else {
recv_size = sctp_stream_request->receive_size;
}
/* we want to set-up our recv_ring in a manner analagous to what we */
/* do on the sending side. this is more for the sake of symmetry */
/* than for the needs of say copy avoidance, but it might also be */
/* more realistic - this way one could conceivably go with a */
/* double-buffering scheme when taking the data an putting it into */
/* the filesystem or something like that. raj 7/94 */
if (recv_width == 0) {
recv_width = (lsr_size/recv_size) + 1;
if (recv_width == 1) recv_width++;
}
recv_ring = allocate_buffer_ring(recv_width,
recv_size,
sctp_stream_request->recv_alignment,
sctp_stream_request->recv_offset);
if (debug) {
fprintf(where,"recv_sctp_stream: receive alignment and offset set...\n");
fflush(where);
}
/* Now, let's set-up the socket to listen for connections */
if (listen(s_recv, 5) == -1) {
netperf_response.content.serv_errno = errno;
close(s_recv);
send_response();
exit(1);
}
/* now get the port number assigned by the system */
addrlen = sizeof(myaddr_in);
if (getsockname(s_recv,
(struct sockaddr *)&myaddr_in,
&addrlen) == -1){
netperf_response.content.serv_errno = errno;
close(s_recv);
send_response();
exit(1);
}
/* Now myaddr_in contains the port and the internet address this is */
/* returned to the sender also implicitly telling the sender that the */
/* socket buffer sizing has been done. */
sctp_stream_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
netperf_response.content.serv_errno = 0;
/* But wait, there's more. If the initiator wanted cpu measurements, */
/* then we must call the calibrate routine, which will return the max */
/* rate back to the initiator. If the CPU was not to be measured, or */
/* something went wrong with the calibration, we will return a -1 to */
/* the initiator. */
sctp_stream_response->cpu_rate = (float)0.0; /* assume no cpu */
if (sctp_stream_request->measure_cpu) {
sctp_stream_response->measure_cpu = 1;
sctp_stream_response->cpu_rate =
calibrate_local_cpu(sctp_stream_request->cpu_rate);
}
else {
sctp_stream_response->measure_cpu = 0;
}
/* before we send the response back to the initiator, pull some of */
/* the socket parms from the globals */
sctp_stream_response->send_buf_size = lss_size;
sctp_stream_response->recv_buf_size = lsr_size;
sctp_stream_response->no_delay = loc_nodelay;
sctp_stream_response->so_rcvavoid = loc_rcvavoid;
sctp_stream_response->so_sndavoid = loc_sndavoid;
sctp_stream_response->receive_size = recv_size;
send_response();
sctp_enable_events(s_recv, SCTP_ASSOC_CHANGE_EV | SCTP_SHUTDOWN_EV);
/* now that we are connected, mark the socket as non-blocking */
if (non_block) {
if (!set_nonblock(s_recv)) {
close(s_recv);
exit(1);
}
}
/* Now it's time to start receiving data on the connection. We will */
/* first grab the apropriate counters and then start grabbing. */
cpu_start(sctp_stream_request->measure_cpu);
/* The loop will exit when the sender does a shutdown, which will */
/* return a length of zero */
#ifdef DIRTY
/* we want to dirty some number of consecutive integers in the buffer */
/* we are about to recv. we may also want to bring some number of */
/* them cleanly into the cache. The clean ones will follow any dirty */
/* ones into the cache. */
dirty_count = sctp_stream_request->dirty_count;
clean_count = sctp_stream_request->clean_count;
message_int_ptr = (int *)recv_ring->buffer_ptr;
for (i = 0; i < dirty_count; i++) {
*message_int_ptr = rand();
message_int_ptr++;
}
for (i = 0; i < clean_count; i++) {
dirty_count = *message_int_ptr;
message_int_ptr++;
}
#endif /* DIRTY */
bytes_received = 0;
receive_calls = 0;
while ((len = sctp_recvmsg(s_recv, recv_ring->buffer_ptr, recv_size,
NULL, 0, /* we don't care who it's from */
NULL, &msg_flags)) != 0) {
if (len < 0) {
if (non_block && errno == EAGAIN) {
Set_errno(0);
continue;
}
netperf_response.content.serv_errno = errno;
send_response();
close(s_recv);
exit(1);
}
if (msg_flags & MSG_NOTIFICATION) {
if (sctp_process_event(s_recv, recv_ring->buffer_ptr) == SCTP_CLOSE)
break;
continue;
}
bytes_received += len;
receive_calls++;
/* more to the next buffer in the recv_ring */
recv_ring = recv_ring->next;
#ifdef PAUSE
sleep(1);
#endif /* PAUSE */
#ifdef DIRTY
message_int_ptr = (int *)(recv_ring->buffer_ptr);
for (i = 0; i < dirty_count; i++) {
*message_int_ptr = rand();
message_int_ptr++;
}
for (i = 0; i < clean_count; i++) {
dirty_count = *message_int_ptr;
message_int_ptr++;
}
#endif /* DIRTY */
#ifdef DO_SELECT
FD_SET(s_recv,&readfds);
select(s_recv+1,&readfds,NULL,NULL,&timeout);
#endif /* DO_SELECT */
}
/* perform a shutdown to signal the sender. in this case, sctp
* will close all associations on this socket
*/
if (close(s_recv) == -1) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
cpu_stop(sctp_stream_request->measure_cpu,&elapsed_time);
/* send the results to the sender */
if (debug) {
fprintf(where,
"recv_sctp_stream: got %g bytes\n",
bytes_received);
fprintf(where,
"recv_sctp_stream: got %d recvs\n",
receive_calls);
fflush(where);
}
sctp_stream_results->bytes_received = htond(bytes_received);
sctp_stream_results->elapsed_time = elapsed_time;
sctp_stream_results->recv_calls = receive_calls;
if (sctp_stream_request->measure_cpu) {
sctp_stream_results->cpu_util = calc_cpu_util(0.0);
};
if (debug) {
fprintf(where,
"recv_sctp_stream: test complete, sending results.\n");
fprintf(where,
" bytes_received %g receive_calls %d\n",
bytes_received,
receive_calls);
fprintf(where,
" len %d\n",
len);
fflush(where);
}
sctp_stream_results->cpu_method = cpu_method;
sctp_stream_results->num_cpus = lib_num_loc_cpus;
send_response();
}
/* this routine implements the sending (netperf) side of the SCTP_RR */
/* test. */
void
send_sctp_rr(remote_host)
char remote_host[];
{
char *tput_title = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Trans.\n\
Send Recv Size Size Time Rate \n\
bytes Bytes bytes bytes secs. per sec \n\n";
char *tput_fmt_0 =
"%7.2f\n";
char *tput_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %7.2f \n";
char *tput_fmt_1_line_2 = "\
%-6d %-6d\n";
char *cpu_title = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Trans. CPU CPU S.dem S.dem\n\
Send Recv Size Size Time Rate local remote local remote\n\
bytes bytes bytes bytes secs. per sec %% %c %% %c us/Tr us/Tr\n\n";
char *cpu_fmt_0 =
"%6.3f %c\n";
char *cpu_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %-6.2f %-6.2f %-6.2f %-6.3f %-6.3f\n";
char *cpu_fmt_1_line_2 = "\
%-6d %-6d\n";
char *ksink_fmt = "\
Alignment Offset\n\
Local Remote Local Remote\n\
Send Recv Send Recv\n\
%5d %5d %5d %5d\n";
int timed_out = 0;
float elapsed_time;
int len;
char *temp_message_ptr;
int nummessages;
int send_socket;
int trans_remaining;
int msg_flags = 0;
double bytes_xferd;
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
int rsp_bytes_left;
int rsp_bytes_recvd;
float local_cpu_utilization;
float local_service_demand;
float remote_cpu_utilization;
float remote_service_demand;
double thruput;
struct sockaddr_storage peer;
struct addrinfo *remote_res;
struct addrinfo *local_res;
struct sctp_rr_request_struct *sctp_rr_request;
struct sctp_rr_response_struct *sctp_rr_response;
struct sctp_rr_results_struct *sctp_rr_result;
#ifdef WANT_INTERVALS
int interval_count;
sigset_t signal_set;
#endif /* WANT_INTERVALS */
sctp_rr_request =
(struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
sctp_rr_response =
(struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
sctp_rr_result =
(struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
#ifdef WANT_HISTOGRAM
time_hist = HIST_new();
#endif /* WANT_HISTOGRAM */
/* since we are now disconnected from the code that established the */
/* control socket, and since we want to be able to use different */
/* protocols and such, we are passed the name of the remote host and */
/* must turn that into the test specific addressing information. */
/* complete_addrinfos will either succede or exit the process */
complete_addrinfos(&remote_res,
&local_res,
remote_host,
SOCK_STREAM,
IPPROTO_SCTP,
0);
if ( print_headers ) {
print_top_test_header("SCTP REQUEST/RESPONSE TEST", local_res, remote_res);
}
/* initialize a few counters */
send_ring = NULL;
recv_ring = NULL;
confidence_iteration = 1;
init_stat();
/* we have a great-big while loop which controls the number of times */
/* we run a particular test. this is for the calculation of a */
/* confidence interval (I really should have stayed awake during */
/* probstats :). If the user did not request confidence measurement */
/* (no confidence is the default) then we will only go though the */
/* loop once. the confidence stuff originates from the folks at IBM */
while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
(confidence_iteration <= iteration_min)) {
/* initialize a few counters. we have to remember that we might be */
/* going through the loop more than once. */
nummessages = 0;
bytes_xferd = 0.0;
times_up = 0;
timed_out = 0;
trans_remaining = 0;
/* set-up the data buffers with the requested alignment and offset. */
/* since this is a request/response test, default the send_width and */
/* recv_width to 1 and not two raj 7/94 */
if (send_width == 0) send_width = 1;
if (recv_width == 0) recv_width = 1;
if (send_ring == NULL) {
send_ring = allocate_buffer_ring(send_width,
req_size,
local_send_align,
local_send_offset);
}
if (recv_ring == NULL) {
recv_ring = allocate_buffer_ring(recv_width,
rsp_size,
local_recv_align,
local_recv_offset);
}
/*set up the data socket */
send_socket = create_data_socket(local_res);
if (send_socket < 0){
perror("netperf: send_sctp_rr: sctp stream data socket");
exit(1);
}
if (debug) {
fprintf(where,"send_sctp_rr: send_socket obtained...\n");
}
/* If the user has requested cpu utilization measurements, we must */
/* calibrate the cpu(s). We will perform this task within the tests */
/* themselves. If the user has specified the cpu rate, then */
/* calibrate_local_cpu will return rather quickly as it will have */
/* nothing to do. If local_cpu_rate is zero, then we will go through */
/* all the "normal" calibration stuff and return the rate back.*/
if (local_cpu_usage) {
local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
}
/* Tell the remote end to do a listen. The server alters the socket */
/* paramters on the other side at this point, hence the reason for */
/* all the values being passed in the setup message. If the user did */
/* not specify any of the parameters, they will be passed as 0, which */
/* will indicate to the remote that no changes beyond the system's */
/* default should be used. Alignment is the exception, it will */
/* default to 8, which will be no alignment alterations. */
netperf_request.content.request_type = DO_SCTP_RR;
sctp_rr_request->recv_buf_size = rsr_size_req;
sctp_rr_request->send_buf_size = rss_size_req;
sctp_rr_request->recv_alignment = remote_recv_align;
sctp_rr_request->recv_offset = remote_recv_offset;
sctp_rr_request->send_alignment = remote_send_align;
sctp_rr_request->send_offset = remote_send_offset;
sctp_rr_request->request_size = req_size;
sctp_rr_request->response_size = rsp_size;
sctp_rr_request->no_delay = rem_nodelay;
sctp_rr_request->measure_cpu = remote_cpu_usage;
sctp_rr_request->cpu_rate = remote_cpu_rate;
sctp_rr_request->so_rcvavoid = rem_rcvavoid;
sctp_rr_request->so_sndavoid = rem_sndavoid;
if (test_time) {
sctp_rr_request->test_length = test_time;
}
else {
sctp_rr_request->test_length = test_trans * -1;
}
sctp_rr_request->non_blocking = non_block;
sctp_rr_request->ipfamily = af_to_nf(remote_res->ai_family);
if (debug > 1) {
fprintf(where,"netperf: send_sctp_rr: requesting SCTP rr test\n");
}
send_request();
/* The response from the remote will contain all of the relevant */
/* socket parameters for this test type. We will put them back into */
/* the variables here so they can be displayed if desired. The */
/* remote will have calibrated CPU if necessary, and will have done */
/* all the needed set-up we will have calibrated the cpu locally */
/* before sending the request, and will grab the counter value right*/
/* after the connect returns. The remote will grab the counter right*/
/* after the accept call. This saves the hassle of extra messages */
/* being sent for the sctp tests. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote listen done.\n");
rsr_size = sctp_rr_response->recv_buf_size;
rss_size = sctp_rr_response->send_buf_size;
rem_nodelay = sctp_rr_response->no_delay;
remote_cpu_usage = sctp_rr_response->measure_cpu;
remote_cpu_rate = sctp_rr_response->cpu_rate;
/* make sure that port numbers are in network order */
set_port_number(remote_res,
(unsigned short)sctp_rr_response->data_port_number);
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/*Connect up to the remote port on the data socket */
if (connect(send_socket,
remote_res->ai_addr,
remote_res->ai_addrlen) <0){
perror("netperf: send_sctp_rr data socket connect failed");
exit(1);
}
/* don't need events for 1-to-1 API with request-response tests */
sctp_enable_events(send_socket, 0);
/* set non-blocking if needed */
if (non_block) {
if (!set_nonblock(send_socket)) {
close(send_socket);
exit(1);
}
}
/* Data Socket set-up is finished. If there were problems, either the */
/* connect would have failed, or the previous response would have */
/* indicated a problem. I failed to see the value of the extra */
/* message after the accept on the remote. If it failed, we'll see it */
/* here. If it didn't, we might as well start pumping data. */
/* Set-up the test end conditions. For a request/response test, they */
/* can be either time or transaction based. */
if (test_time) {
/* The user wanted to end the test after a period of time. */
times_up = 0;
trans_remaining = 0;
start_timer(test_time);
}
else {
/* The tester wanted to send a number of bytes. */
trans_remaining = test_bytes;
times_up = 1;
}
/* The cpu_start routine will grab the current time and possibly */
/* value of the idle counter for later use in measuring cpu */
/* utilization and/or service demand and thruput. */
cpu_start(local_cpu_usage);
#ifdef WANT_INTERVALS
if ((interval_burst) || (demo_mode)) {
/* zero means that we never pause, so we never should need the */
/* interval timer, unless we are in demo_mode */
start_itimer(interval_wate);
}
interval_count = interval_burst;
/* get the signal set for the call to sigsuspend */
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
fprintf(where,
"send_sctp_rr: unable to get sigmask errno %d\n",
errno);
fflush(where);
exit(1);
}
#endif /* WANT_INTERVALS */
/* We use an "OR" to control test execution. When the test is */
/* controlled by time, the byte count check will always return false. */
/* When the test is controlled by byte count, the time test will */
/* always return false. When the test is finished, the whole */
/* expression will go false and we will stop sending data. I think I */
/* just arbitrarily decrement trans_remaining for the timed test, but */
/* will not do that just yet... One other question is whether or not */
/* the send buffer and the receive buffer should be the same buffer. */
#ifdef WANT_FIRST_BURST
{
int i;
for (i = 0; i < first_burst_size; i++) {
if((len=sctp_sendmsg(send_socket,
send_ring->buffer_ptr, req_size,
NULL, 0, /* don't need addrs with 1-to-1 */
0, 0, 0, 0, 0)) != req_size) {
/* we should never hit the end of the test in the first burst */
perror("send_sctp_rr: initial burst data send error");
exit(1);
}
}
}
#endif /* WANT_FIRST_BURST */
while ((!times_up) || (trans_remaining > 0)) {
/* send the request. we assume that if we use a blocking socket, */
/* the request will be sent at one shot. */
#ifdef WANT_HISTOGRAM
/* timestamp just before our call to send, and then again just */
/* after the receive raj 8/94 */
HIST_timestamp(&time_one);
#endif /* WANT_HISTOGRAM */
while ((len=sctp_sendmsg(send_socket,
send_ring->buffer_ptr, req_size,
NULL, 0, /* don't need addrs with 1-to-1 */
0, 0, 0, 0, 0)) != req_size) {
if (non_block && errno == EAGAIN) {
/* try sending again */
continue;
} else if (SOCKET_EINTR(len) || (errno == 0)) {
/* we hit the end of a */
/* timed test. */
timed_out = 1;
break;
}
perror("send_sctp_rr: data send error");
exit(1);
}
if (timed_out) {
/* we timed out while sending. break out another level */
break;
}
send_ring = send_ring->next;
/* receive the response */
rsp_bytes_left = rsp_size;
temp_message_ptr = recv_ring->buffer_ptr;
do {
msg_flags = 0;
if ((rsp_bytes_recvd=sctp_recvmsg(send_socket,
temp_message_ptr, rsp_bytes_left,
NULL, 0,
NULL, &msg_flags)) < 0) {
if (errno == EINTR) {
/* We hit the end of a timed test. */
timed_out = 1;
break;
} else if (non_block && errno == EAGAIN) {
continue;
}
perror("send_sctp_rr: data recv error");
exit(1);
}
rsp_bytes_left -= rsp_bytes_recvd;
temp_message_ptr += rsp_bytes_recvd;
} while (!(msg_flags & MSG_EOR));
recv_ring = recv_ring->next;
if (timed_out) {
/* we may have been in a nested while loop - we need */
/* another call to break. */
break;
}
#ifdef WANT_HISTOGRAM
HIST_timestamp(&time_two);
HIST_add(time_hist,delta_micro(&time_one,&time_two));
#endif /* WANT_HISTOGRAM */
#ifdef WANT_INTERVALS
if (demo_mode) {
units_this_tick += 1;
}
/* in this case, the interval count is the count-down couter */
/* to decide to sleep for a little bit */
if ((interval_burst) && (--interval_count == 0)) {
/* call sigsuspend and wait for the interval timer to get us */
/* out */
if (debug > 1) {
fprintf(where,"about to suspend\n");
fflush(where);
}
if (sigsuspend(&signal_set) == EFAULT) {
fprintf(where,
"send_sctp_rr: fault with signal set!\n");
fflush(where);
exit(1);
}
interval_count = interval_burst;
}
#endif /* WANT_INTERVALS */
nummessages++;
if (trans_remaining) {
trans_remaining--;
}
if (debug > 3) {
if ((nummessages % 100) == 0) {
fprintf(where,
"Transaction %d completed\n",
nummessages);
fflush(where);
}
}
}
/* At this point we used to call shutdown on the data socket to be */
/* sure all the data was delivered, but this was not germane in a */
/* request/response test, and it was causing the tests to "hang" when */
/* they were being controlled by time. So, I have replaced this */
/* shutdown call with a call to close that can be found later in the */
/* procedure. */
/* this call will always give us the elapsed time for the test, and */
/* will also store-away the necessaries for cpu utilization */
cpu_stop(local_cpu_usage,&elapsed_time); /* was cpu being */
/* measured? how long */
/* did we really run? */
/* Get the statistics from the remote end. The remote will have */
/* calculated CPU utilization. If it wasn't supposed to care, it */
/* will return obvious values. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote results obtained\n");
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/* We now calculate what our throughput was for the test. */
bytes_xferd = (req_size * nummessages) + (rsp_size * nummessages);
thruput = nummessages/elapsed_time;
if (local_cpu_usage || remote_cpu_usage) {
/* We must now do a little math for service demand and cpu */
/* utilization for the system(s) */
/* Of course, some of the information might be bogus because */
/* there was no idle counter in the kernel(s). We need to make */
/* a note of this for the user's benefit...*/
if (local_cpu_usage) {
local_cpu_utilization = calc_cpu_util(0.0);
/* since calc_service demand is doing ms/Kunit we will */
/* multiply the number of transaction by 1024 to get */
/* "good" numbers */
local_service_demand = calc_service_demand((double) nummessages*1024,
0.0,
0.0,
0);
}
else {
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
}
if (remote_cpu_usage) {
remote_cpu_utilization = sctp_rr_result->cpu_util;
/* since calc_service demand is doing ms/Kunit we will */
/* multiply the number of transaction by 1024 to get */
/* "good" numbers */
remote_service_demand = calc_service_demand((double) nummessages*1024,
0.0,
remote_cpu_utilization,
sctp_rr_result->num_cpus);
}
else {
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
}
else {
/* we were not measuring cpu, for the confidence stuff, we */
/* should make it -1.0 */
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
/* at this point, we want to calculate the confidence information. */
/* if debugging is on, calculate_confidence will print-out the */
/* parameters we pass it */
calculate_confidence(confidence_iteration,
elapsed_time,
thruput,
local_cpu_utilization,
remote_cpu_utilization,
local_service_demand,
remote_service_demand);
confidence_iteration++;
/* we are now done with the socket, so close it */
close(send_socket);
}
retrieve_confident_values(&elapsed_time,
&thruput,
&local_cpu_utilization,
&remote_cpu_utilization,
&local_service_demand,
&remote_service_demand);
/* We are now ready to print all the information. If the user */
/* has specified zero-level verbosity, we will just print the */
/* local service demand, or the remote service demand. If the */
/* user has requested verbosity level 1, he will get the basic */
/* "streamperf" numbers. If the user has specified a verbosity */
/* of greater than 1, we will display a veritable plethora of */
/* background information from outside of this block as it it */
/* not cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
local_cpu_method = format_cpu_method(cpu_method);
remote_cpu_method = format_cpu_method(sctp_rr_result->cpu_method);
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1_line_1, /* the format string */
lss_size, /* local sendbuf size */
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* guess */
elapsed_time, /* how long was the test */
thruput,
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand); /* remote service demand */
fprintf(where,
cpu_fmt_1_line_2,
rss_size,
rsr_size);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1_line_1, /* the format string */
lss_size,
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* how large were the responses */
elapsed_time, /* how long did it take */
thruput);
fprintf(where,
tput_fmt_1_line_2,
rss_size, /* remote recvbuf size */
rsr_size);
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
/* how to handle the verbose information in the presence of */
/* confidence intervals is yet to be determined... raj 11/94 */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* TCP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
fprintf(where,
ksink_fmt,
local_send_align,
remote_recv_offset,
local_send_offset,
remote_recv_offset);
#ifdef WANT_HISTOGRAM
fprintf(where,"\nHistogram of request/response times\n");
fflush(where);
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
}
}
/* this routine implements the receive (netserver) side of a TCP_RR */
/* test */
void
recv_sctp_rr()
{
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
struct addrinfo *local_res;
char local_name[BUFSIZ];
char port_buffer[PORTBUFSIZE];
struct sockaddr_in myaddr_in, peeraddr_in;
int s_listen, s_data;
int addrlen;
char *temp_message_ptr;
int trans_received;
int trans_remaining;
int bytes_sent;
int request_bytes_recvd;
int request_bytes_remaining;
int timed_out = 0;
float elapsed_time;
struct sctp_rr_request_struct *sctp_rr_request;
struct sctp_rr_response_struct *sctp_rr_response;
struct sctp_rr_results_struct *sctp_rr_results;
sctp_rr_request =
(struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
sctp_rr_response =
(struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
sctp_rr_results =
(struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
if (debug) {
fprintf(where,"netserver: recv_sctp_rr: entered...\n");
fflush(where);
}
/* We want to set-up the listen socket with all the desired */
/* parameters and then let the initiator know that all is ready. If */
/* socket size defaults are to be used, then the initiator will have */
/* sent us 0's. If the socket sizes cannot be changed, then we will */
/* send-back what they are. If that information cannot be determined, */
/* then we send-back -1's for the sizes. If things go wrong for any */
/* reason, we will drop back ten yards and punt. */
/* If anything goes wrong, we want the remote to know about it. It */
/* would be best if the error that the remote reports to the user is */
/* the actual error we encountered, rather than some bogus unexpected */
/* response type message. */
if (debug) {
fprintf(where,"recv_sctp_rr: setting the response type...\n");
fflush(where);
}
netperf_response.content.response_type = SCTP_RR_RESPONSE;
if (debug) {
fprintf(where,"recv_sctp_rr: the response type is set...\n");
fflush(where);
}
/* allocate the recv and send rings with the requested alignments */
/* and offsets. raj 7/94 */
if (debug) {
fprintf(where,"recv_sctp_rr: requested recv alignment of %d offset %d\n",
sctp_rr_request->recv_alignment,
sctp_rr_request->recv_offset);
fprintf(where,"recv_sctp_rr: requested send alignment of %d offset %d\n",
sctp_rr_request->send_alignment,
sctp_rr_request->send_offset);
fflush(where);
}
/* at some point, these need to come to us from the remote system */
if (send_width == 0) send_width = 1;
if (recv_width == 0) recv_width = 1;
send_ring = allocate_buffer_ring(send_width,
sctp_rr_request->response_size,
sctp_rr_request->send_alignment,
sctp_rr_request->send_offset);
recv_ring = allocate_buffer_ring(recv_width,
sctp_rr_request->request_size,
sctp_rr_request->recv_alignment,
sctp_rr_request->recv_offset);
/* Grab a socket to listen on, and then listen on it. */
if (debug) {
fprintf(where,"recv_sctp_rr: grabbing a socket...\n");
fflush(where);
}
/* create_data_socket expects to find some things in the global */
/* variables, so set the globals based on the values in the request. */
/* once the socket has been created, we will set the response values */
/* based on the updated value of those globals. raj 7/94 */
lss_size_req = sctp_rr_request->send_buf_size;
lsr_size_req = sctp_rr_request->recv_buf_size;
loc_nodelay = sctp_rr_request->no_delay;
loc_rcvavoid = sctp_rr_request->so_rcvavoid;
loc_sndavoid = sctp_rr_request->so_sndavoid;
non_block = sctp_rr_request->non_blocking;
set_hostname_and_port(local_name,
port_buffer,
nf_to_af(sctp_rr_request->ipfamily),
sctp_rr_request->port);
local_res = complete_addrinfo(local_name,
local_name,
port_buffer,
nf_to_af(sctp_rr_request->ipfamily),
SOCK_STREAM,
IPPROTO_SCTP,
0);
s_listen = create_data_socket(local_res);
if (s_listen < 0) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
/* Now, let's set-up the socket to listen for connections */
if (listen(s_listen, 5) == -1) {
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
exit(1);
}
/* now get the port number assigned by the system */
addrlen = sizeof(myaddr_in);
if (getsockname(s_listen,
(struct sockaddr *)&myaddr_in, &addrlen) == -1){
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
exit(1);
}
/* Now myaddr_in contains the port and the internet address this is */
/* returned to the sender also implicitly telling the sender that the */
/* socket buffer sizing has been done. */
sctp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
netperf_response.content.serv_errno = 0;
/* But wait, there's more. If the initiator wanted cpu measurements, */
/* then we must call the calibrate routine, which will return the max */
/* rate back to the initiator. If the CPU was not to be measured, or */
/* something went wrong with the calibration, we will return a 0.0 to */
/* the initiator. */
sctp_rr_response->cpu_rate = (float)0.0; /* assume no cpu */
sctp_rr_response->measure_cpu = 0;
if (sctp_rr_request->measure_cpu) {
sctp_rr_response->measure_cpu = 1;
sctp_rr_response->cpu_rate = calibrate_local_cpu(sctp_rr_request->cpu_rate);
}
/* before we send the response back to the initiator, pull some of */
/* the socket parms from the globals */
sctp_rr_response->send_buf_size = lss_size;
sctp_rr_response->recv_buf_size = lsr_size;
sctp_rr_response->no_delay = loc_nodelay;
sctp_rr_response->so_rcvavoid = loc_rcvavoid;
sctp_rr_response->so_sndavoid = loc_sndavoid;
sctp_rr_response->test_length = sctp_rr_request->test_length;
send_response();
addrlen = sizeof(peeraddr_in);
if ((s_data = accept(s_listen,
(struct sockaddr *)&peeraddr_in,
&addrlen)) == -1) {
/* Let's just punt. The remote will be given some information */
close(s_listen);
exit(1);
}
/* we do not need events on a 1-to-1 RR test. The test will finish
* once all transactions are done.
*/
/* now that we are connected, mark the socket as non-blocking */
if (non_block) {
if (!set_nonblock(s_data)) {
perror("netperf: set_nonblock");
exit(1);
}
}
#ifdef KLUDGE_SOCKET_OPTIONS
/* this is for those systems which *INCORRECTLY* fail to pass */
/* attributes across an accept() call. Including this goes against */
/* my better judgement :( raj 11/95 */
kludge_socket_options(s_data);
#endif /* KLUDGE_SOCKET_OPTIONS */
if (debug) {
fprintf(where,"recv_sctp_rr: accept completes on the data connection.\n");
fflush(where);
}
/* Now it's time to start receiving data on the connection. We will */
/* first grab the apropriate counters and then start grabbing. */
cpu_start(sctp_rr_request->measure_cpu);
/* The loop will exit when we hit the end of the test time, or when */
/* we have exchanged the requested number of transactions. */
if (sctp_rr_request->test_length > 0) {
times_up = 0;
trans_remaining = 0;
start_timer(sctp_rr_request->test_length + PAD_TIME);
}
else {
times_up = 1;
trans_remaining = sctp_rr_request->test_length * -1;
}
trans_received = 0;
while ((!times_up) || (trans_remaining > 0)) {
int msg_flags = 0;
temp_message_ptr = recv_ring->buffer_ptr;
request_bytes_remaining = sctp_rr_request->request_size;
while(!(msg_flags & MSG_EOR)) {
if((request_bytes_recvd=sctp_recvmsg(s_data,
temp_message_ptr,
request_bytes_remaining,
NULL, 0,
NULL, &msg_flags)) < 0) {
if (errno == EINTR) {
/* the timer popped */
timed_out = 1;
break;
} else if (non_block && errno == EAGAIN) {
continue; /* while request_bytes_remaining */
}
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
request_bytes_remaining -= request_bytes_recvd;
temp_message_ptr += request_bytes_recvd;
}
recv_ring = recv_ring->next;
if (timed_out) {
/* we hit the end of the test based on time - lets */
/* bail out of here now... */
if (debug) {
fprintf(where,"yo55\n");
fflush(where);
}
break;
}
/* Now, send the response to the remote
* In 1-to-1 API destination addr is not needed.
*/
while ((bytes_sent=sctp_sendmsg(s_data,
send_ring->buffer_ptr,
sctp_rr_request->response_size,
NULL, 0,
0, 0, 0, 0, 0)) == -1) {
if (errno == EINTR) {
/* the test timer has popped */
timed_out = 1;
break;
} else if (non_block && errno == EAGAIN) {
continue;
}
netperf_response.content.serv_errno = 982;
send_response();
exit(1);
}
if (timed_out) {
/* we hit the end of the test based on time - lets */
/* bail out of here now... */
if (debug) {
fprintf(where,"yo6\n");
fflush(where);
}
break;
}
send_ring = send_ring->next;
trans_received++;
if (trans_remaining) {
trans_remaining--;
}
}
/* The loop now exits due to timeout or transaction count being */
/* reached */
cpu_stop(sctp_rr_request->measure_cpu,&elapsed_time);
stop_timer();
if (timed_out) {
/* we ended the test by time, which was at least 2 seconds */
/* longer than we wanted to run. so, we want to subtract */
/* PAD_TIME from the elapsed_time. */
elapsed_time -= PAD_TIME;
}
/* send the results to the sender */
if (debug) {
fprintf(where,
"recv_sctp_rr: got %d transactions\n",
trans_received);
fflush(where);
}
sctp_rr_results->bytes_received = (trans_received *
(sctp_rr_request->request_size +
sctp_rr_request->response_size));
sctp_rr_results->trans_received = trans_received;
sctp_rr_results->elapsed_time = elapsed_time;
sctp_rr_results->cpu_method = cpu_method;
sctp_rr_results->num_cpus = lib_num_loc_cpus;
if (sctp_rr_request->measure_cpu) {
sctp_rr_results->cpu_util = calc_cpu_util(elapsed_time);
}
if (debug) {
fprintf(where,
"recv_sctp_rr: test complete, sending results.\n");
fflush(where);
}
/* we are now done with the sockets */
send_response();
close(s_data);
close(s_listen);
}
/* this routine implements the sending (netperf) side of the
SCTP_RR_1TOMANY test */
void
send_sctp_rr_1toMany(remote_host)
char remote_host[];
{
char *tput_title = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Trans.\n\
Send Recv Size Size Time Rate \n\
bytes Bytes bytes bytes secs. per sec \n\n";
char *tput_fmt_0 =
"%7.2f\n";
char *tput_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %7.2f \n";
char *tput_fmt_1_line_2 = "\
%-6d %-6d\n";
char *cpu_title = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Trans. CPU CPU S.dem S.dem\n\
Send Recv Size Size Time Rate local remote local remote\n\
bytes bytes bytes bytes secs. per sec %% %c %% %c us/Tr us/Tr\n\n";
char *cpu_fmt_0 =
"%6.3f %c\n";
char *cpu_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %-6.2f %-6.2f %-6.2f %-6.3f %-6.3f\n";
char *cpu_fmt_1_line_2 = "\
%-6d %-6d\n";
char *ksink_fmt = "\
Alignment Offset\n\
Local Remote Local Remote\n\
Send Recv Send Recv\n\
%5d %5d %5d %5d\n";
int timed_out = 0;
float elapsed_time;
int len, j = 0;
char *temp_message_ptr;
int nummessages;
int *send_socket;
int trans_remaining;
double bytes_xferd;
int msg_flags = 0;
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
int rsp_bytes_left;
int rsp_bytes_recvd;
float local_cpu_utilization;
float local_service_demand;
float remote_cpu_utilization;
float remote_service_demand;
double thruput;
struct sockaddr_storage peer;
struct addrinfo *local_res;
struct addrinfo *remote_res;
struct sctp_rr_request_struct *sctp_rr_request;
struct sctp_rr_response_struct *sctp_rr_response;
struct sctp_rr_results_struct *sctp_rr_result;
#ifdef WANT_INTERVALS
int interval_count;
sigset_t signal_set;
#endif /* WANT_INTERVALS */
sctp_rr_request =
(struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
sctp_rr_response =
(struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
sctp_rr_result =
(struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
#ifdef WANT_HISTOGRAM
time_hist = HIST_new();
#endif /* WANT_HISTOGRAM */
/* since we are now disconnected from the code that established the */
/* control socket, and since we want to be able to use different */
/* protocols and such, we are passed the name of the remote host and */
/* must turn that into the test specific addressing information. */
complete_addrinfos(&remote_res,
&local_res,
remote_host,
SOCK_SEQPACKET,
IPPROTO_SCTP,
0);
if ( print_headers ) {
print_top_test_header("SCTP 1-TO-MANY REQUEST/RESPONSE TEST",local_res,remote_res);
}
/* initialize a few counters */
send_ring = NULL;
recv_ring = NULL;
confidence_iteration = 1;
init_stat();
send_socket = malloc(sizeof(int) * num_associations);
if (send_socket == NULL) {
fprintf(where,
"Could not create the socket array for %d associations",
num_associations);
fflush(where);
exit(1);
}
/* we have a great-big while loop which controls the number of times */
/* we run a particular test. this is for the calculation of a */
/* confidence interval (I really should have stayed awake during */
/* probstats :). If the user did not request confidence measurement */
/* (no confidence is the default) then we will only go though the */
/* loop once. the confidence stuff originates from the folks at IBM */
while (((confidence < 0) && (confidence_iteration < iteration_max)) ||
(confidence_iteration <= iteration_min)) {
/* initialize a few counters. we have to remember that we might be */
/* going through the loop more than once. */
nummessages = 0;
bytes_xferd = 0.0;
times_up = 0;
timed_out = 0;
trans_remaining = 0;
/* set-up the data buffers with the requested alignment and offset. */
/* since this is a request/response test, default the send_width and */
/* recv_width to 1 and not two raj 7/94 */
if (send_width == 0) send_width = 1;
if (recv_width == 0) recv_width = 1;
if (send_ring == NULL) {
send_ring = allocate_buffer_ring(send_width,
req_size,
local_send_align,
local_send_offset);
}
if (recv_ring == NULL) {
recv_ring = allocate_buffer_ring(recv_width,
rsp_size,
local_recv_align,
local_recv_offset);
}
/* If the user has requested cpu utilization measurements, we must */
/* calibrate the cpu(s). We will perform this task within the tests */
/* themselves. If the user has specified the cpu rate, then */
/* calibrate_local_cpu will return rather quickly as it will have */
/* nothing to do. If local_cpu_rate is zero, then we will go through */
/* all the "normal" calibration stuff and return the rate back.*/
if (local_cpu_usage) {
local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
}
/* Tell the remote end to do a listen. The server alters the socket */
/* paramters on the other side at this point, hence the reason for */
/* all the values being passed in the setup message. If the user did */
/* not specify any of the parameters, they will be passed as 0, which */
/* will indicate to the remote that no changes beyond the system's */
/* default should be used. Alignment is the exception, it will */
/* default to 8, which will be no alignment alterations. */
netperf_request.content.request_type = DO_SCTP_RR_MANY;
sctp_rr_request->recv_buf_size = rsr_size_req;
sctp_rr_request->send_buf_size = rss_size_req;
sctp_rr_request->recv_alignment = remote_recv_align;
sctp_rr_request->recv_offset = remote_recv_offset;
sctp_rr_request->send_alignment = remote_send_align;
sctp_rr_request->send_offset = remote_send_offset;
sctp_rr_request->request_size = req_size;
sctp_rr_request->response_size = rsp_size;
sctp_rr_request->no_delay = rem_nodelay;
sctp_rr_request->measure_cpu = remote_cpu_usage;
sctp_rr_request->cpu_rate = remote_cpu_rate;
sctp_rr_request->so_rcvavoid = rem_rcvavoid;
sctp_rr_request->so_sndavoid = rem_sndavoid;
if (test_time) {
sctp_rr_request->test_length = test_time;
}
else {
sctp_rr_request->test_length = test_trans * num_associations
* -1;
}
sctp_rr_request->non_blocking = non_block;
sctp_rr_request->port = atoi(remote_data_port);
sctp_rr_request->ipfamily = af_to_nf(remote_res->ai_family);
if (debug > 1) {
fprintf(where,"netperf: send_sctp_rr_1toMany: requesting SCTP rr test\n");
}
send_request();
/* The response from the remote will contain all of the relevant */
/* socket parameters for this test type. We will put them back into */
/* the variables here so they can be displayed if desired. The */
/* remote will have calibrated CPU if necessary, and will have done */
/* all the needed set-up we will have calibrated the cpu locally */
/* before sending the request, and will grab the counter value right*/
/* after the connect returns. The remote will grab the counter right*/
/* after the accept call. This saves the hassle of extra messages */
/* being sent for the sctp tests. */
recv_response();
if (!netperf_response.content.serv_errno) {
rsr_size = sctp_rr_response->recv_buf_size;
rss_size = sctp_rr_response->send_buf_size;
rem_nodelay = sctp_rr_response->no_delay;
remote_cpu_usage = sctp_rr_response->measure_cpu;
remote_cpu_rate = sctp_rr_response->cpu_rate;
/* make sure that port numbers are in network order */
set_port_number(remote_res,
(unsigned short)sctp_rr_response->data_port_number);
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/*set up the data socket list */
for (j = 0; j < num_associations; j++) {
send_socket[j] = create_data_socket(local_res);
if (send_socket < 0){
perror("netperf: send_sctp_rr_1toMany: sctp stream data socket");
exit(1);
}
/*Connect up to the remote port on the data socket */
if (connect(send_socket[j],
remote_res->ai_addr,
remote_res->ai_addrlen) < 0){
perror("netperf: data socket connect failed");
exit(1);
}
/* The client end of the 1-to-Many test uses 1-to-1 sockets.
* it doesn't need events.
*/
sctp_enable_events(send_socket[j], 0);
if (non_block) {
if (!set_nonblock(send_socket[j])) {
close(send_socket[j]);
exit(1);
}
}
}
/* Data Socket set-up is finished. If there were problems, either the */
/* connect would have failed, or the previous response would have */
/* indicated a problem. I failed to see the value of the extra */
/* message after the accept on the remote. If it failed, we'll see it */
/* here. If it didn't, we might as well start pumping data. */
/* Set-up the test end conditions. For a request/response test, they */
/* can be either time or transaction based. */
if (test_time) {
/* The user wanted to end the test after a period of time. */
times_up = 0;
trans_remaining = 0;
start_timer(test_time);
}
else {
/* The tester wanted to send a number of bytes. */
trans_remaining = test_bytes * num_associations;
times_up = 1;
}
/* The cpu_start routine will grab the current time and possibly */
/* value of the idle counter for later use in measuring cpu */
/* utilization and/or service demand and thruput. */
cpu_start(local_cpu_usage);
#ifdef WANT_INTERVALS
if ((interval_burst) || (demo_mode)) {
/* zero means that we never pause, so we never should need the */
/* interval timer, unless we are in demo_mode */
start_itimer(interval_wate);
}
interval_count = interval_burst;
/* get the signal set for the call to sigsuspend */
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) {
fprintf(where,
"send_sctp_rr_1toMany: unable to get sigmask errno %d\n",
errno);
fflush(where);
exit(1);
}
#endif /* WANT_INTERVALS */
/* We use an "OR" to control test execution. When the test is */
/* controlled by time, the byte count check will always return false. */
/* When the test is controlled by byte count, the time test will */
/* always return false. When the test is finished, the whole */
/* expression will go false and we will stop sending data. I think I */
/* just arbitrarily decrement trans_remaining for the timed test, but */
/* will not do that just yet... One other question is whether or not */
/* the send buffer and the receive buffer should be the same buffer. */
#ifdef WANT_FIRST_BURST
{
int i;
for (j = 0; j < num_associations; j++) {
for (i = 0; i < first_burst_size; i++) {
if((len=sctp_sendmsg(send_socket[j],
send_ring->buffer_ptr, send_size,
remote_res->ai_addr,
remote_res->ai_addrlen,
0, 0, 0, 0, 0)) != req_size) {
/* we should never hit the end of the test in the first burst */
perror("send_sctp_rr_1toMany: initial burst data send error");
exit(1);
}
}
}
}
#endif /* WANT_FIRST_BURST */
while ((!times_up) || (trans_remaining > 0)) {
/* send the request. we assume that if we use a blocking socket, */
/* the request will be sent at one shot. */
/* this is a fairly poor way of testing 1toMany connections.
* For each association we measure round trip time to account for
* any delay in lookups and delivery. To stress the server a bit
* more we would need a distributed client test, or at least multiple
* processes. I want to force as much paralellism as possible, but
* this will do for the fist take. vlad
*/
for (j = 0; j < num_associations; j++) {
#ifdef WANT_HISTOGRAM
/* timestamp just before our call to send, and then again just */
/* after the receive raj 8/94 */
gettimeofday(&time_one,NULL);
#endif /* WANT_HISTOGRAM */
while ((len=sctp_sendmsg(send_socket[j],
send_ring->buffer_ptr, send_size,
remote_res->ai_addr,
remote_res->ai_addrlen,
0, 0, 0, 0, 0)) != req_size) {
if (non_block && errno == EAGAIN) {
/* try sending again */
continue;
} else if ((errno == EINTR) || (errno == 0)) {
/* we hit the end of a */
/* timed test. */
timed_out = 1;
break;
}
perror("send_sctp_rr_1toMany: data send error");
exit(1);
}
if (timed_out) {
/* we may have been in a nested while loop - we need */
/* another call to break. */
break;
}
/* setup for the next time */
send_ring = send_ring->next;
rsp_bytes_left = rsp_size;
temp_message_ptr = recv_ring->buffer_ptr;
while (!(msg_flags & MSG_EOR)) {
if((rsp_bytes_recvd = sctp_recvmsg(send_socket[j],
temp_message_ptr,
rsp_bytes_left,
NULL, 0,
NULL, &msg_flags)) < 0) {
if (errno == EINTR) {
/* We hit the end of a timed test. */
timed_out = 1;
break;
} else if (non_block && errno == EAGAIN) {
continue;
}
perror("send_sctp_rr_1toMany: data recv error");
exit(1);
}
rsp_bytes_left -= rsp_bytes_recvd;
temp_message_ptr += rsp_bytes_recvd;
}
recv_ring = recv_ring->next;
if (timed_out) {
/* we may have been in a nested while loop - we need */
/* another call to break. */
break;
}
#ifdef WANT_HISTOGRAM
gettimeofday(&time_two,NULL);
HIST_add(time_hist,delta_micro(&time_one,&time_two));
#endif /* WANT_HISTOGRAM */
nummessages++;
if (trans_remaining) {
trans_remaining--;
}
if (debug > 3) {
if ((nummessages % 100) == 0) {
fprintf(where,
"Transaction %d completed\n",
nummessages);
fflush(where);
}
}
}
}
/* At this point we used to call shutdown on the data socket to be */
/* sure all the data was delivered, but this was not germane in a */
/* request/response test, and it was causing the tests to "hang" when */
/* they were being controlled by time. So, I have replaced this */
/* shutdown call with a call to close that can be found later in the */
/* procedure. */
/* this call will always give us the elapsed time for the test, and */
/* will also store-away the necessaries for cpu utilization */
cpu_stop(local_cpu_usage,&elapsed_time); /* was cpu being */
/* measured? how long */
/* did we really run? */
/* Get the statistics from the remote end. The remote will have */
/* calculated CPU utilization. If it wasn't supposed to care, it */
/* will return obvious values. */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote results obtained\n");
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(1);
}
/* We now calculate what our throughput was for the test. */
bytes_xferd = (req_size * nummessages) + (rsp_size * nummessages);
thruput = nummessages/elapsed_time;
if (local_cpu_usage || remote_cpu_usage) {
/* We must now do a little math for service demand and cpu */
/* utilization for the system(s) */
/* Of course, some of the information might be bogus because */
/* there was no idle counter in the kernel(s). We need to make */
/* a note of this for the user's benefit...*/
if (local_cpu_usage) {
local_cpu_utilization = calc_cpu_util(0.0);
/* since calc_service demand is doing ms/Kunit we will */
/* multiply the number of transaction by 1024 to get */
/* "good" numbers */
local_service_demand = calc_service_demand((double) nummessages*1024,
0.0,
0.0,
0);
}
else {
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
}
if (remote_cpu_usage) {
remote_cpu_utilization = sctp_rr_result->cpu_util;
/* since calc_service demand is doing ms/Kunit we will */
/* multiply the number of transaction by 1024 to get */
/* "good" numbers */
remote_service_demand = calc_service_demand((double) nummessages*1024,
0.0,
remote_cpu_utilization,
sctp_rr_result->num_cpus);
}
else {
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
}
else {
/* we were not measuring cpu, for the confidence stuff, we */
/* should make it -1.0 */
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
/* at this point, we want to calculate the confidence information. */
/* if debugging is on, calculate_confidence will print-out the */
/* parameters we pass it */
calculate_confidence(confidence_iteration,
elapsed_time,
thruput,
local_cpu_utilization,
remote_cpu_utilization,
local_service_demand,
remote_service_demand);
confidence_iteration++;
/* we are now done with the socket, so close it */
for (j = 0; j < num_associations; j++)
close(send_socket[j]);
}
retrieve_confident_values(&elapsed_time,
&thruput,
&local_cpu_utilization,
&remote_cpu_utilization,
&local_service_demand,
&remote_service_demand);
/* We are now ready to print all the information. If the user */
/* has specified zero-level verbosity, we will just print the */
/* local service demand, or the remote service demand. If the */
/* user has requested verbosity level 1, he will get the basic */
/* "streamperf" numbers. If the user has specified a verbosity */
/* of greater than 1, we will display a veritable plethora of */
/* background information from outside of this block as it it */
/* not cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
local_cpu_method = format_cpu_method(cpu_method);
remote_cpu_method = format_cpu_method(sctp_rr_result->cpu_method);
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1_line_1, /* the format string */
lss_size, /* local sendbuf size */
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* guess */
elapsed_time, /* how long was the test */
thruput,
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand); /* remote service demand */
fprintf(where,
cpu_fmt_1_line_2,
rss_size,
rsr_size);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1_line_1, /* the format string */
lss_size,
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* how large were the responses */
elapsed_time, /* how long did it take */
thruput);
fprintf(where,
tput_fmt_1_line_2,
rss_size, /* remote recvbuf size */
rsr_size);
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
/* how to handle the verbose information in the presence of */
/* confidence intervals is yet to be determined... raj 11/94 */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* TCP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
fprintf(where,
ksink_fmt,
local_send_align,
remote_recv_offset,
local_send_offset,
remote_recv_offset);
#ifdef WANT_HISTOGRAM
fprintf(where,"\nHistogram of request/response times\n");
fflush(where);
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
}
}
/* this routine implements the receive (netserver) side of a TCP_RR */
/* test */
void
recv_sctp_rr_1toMany()
{
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
struct sockaddr_in myaddr_in; /* needed to get the port number */
struct sockaddr_storage peeraddr; /* to communicate with peer */
struct addrinfo *local_res;
char local_name[BUFSIZ];
char port_buffer[PORTBUFSIZE];
int msg_flags;
int s_rcv;
int addrlen;
char *temp_message_ptr;
int trans_received;
int trans_remaining;
int bytes_sent;
int bytes_recvd;
int recv_buf_size;
int timed_out = 0;
float elapsed_time;
struct sctp_rr_request_struct *sctp_rr_request;
struct sctp_rr_response_struct *sctp_rr_response;
struct sctp_rr_results_struct *sctp_rr_results;
sctp_rr_request =
(struct sctp_rr_request_struct *)netperf_request.content.test_specific_data;
sctp_rr_response =
(struct sctp_rr_response_struct *)netperf_response.content.test_specific_data;
sctp_rr_results =
(struct sctp_rr_results_struct *)netperf_response.content.test_specific_data;
if (debug) {
fprintf(where,"netserver: recv_sctp_rr_1toMany: entered...\n");
fflush(where);
}
/* We want to set-up the listen socket with all the desired */
/* parameters and then let the initiator know that all is ready. If */
/* socket size defaults are to be used, then the initiator will have */
/* sent us 0's. If the socket sizes cannot be changed, then we will */
/* send-back what they are. If that information cannot be determined, */
/* then we send-back -1's for the sizes. If things go wrong for any */
/* reason, we will drop back ten yards and punt. */
/* If anything goes wrong, we want the remote to know about it. It */
/* would be best if the error that the remote reports to the user is */
/* the actual error we encountered, rather than some bogus unexpected */
/* response type message. */
if (debug) {
fprintf(where,"recv_sctp_rr_1toMany: setting the response type...\n");
fflush(where);
}
netperf_response.content.response_type = SCTP_RR_MANY_RESPONSE;
if (debug) {
fprintf(where,"recv_sctp_rr_1toMany: the response type is set...\n");
fflush(where);
}
/* allocate the recv and send rings with the requested alignments */
/* and offsets. raj 7/94 */
if (debug) {
fprintf(where,"recv_sctp_rr_1toMany: requested recv alignment of %d offset %d\n",
sctp_rr_request->recv_alignment,
sctp_rr_request->recv_offset);
fprintf(where,"recv_sctp_rr_1toMany: requested send alignment of %d offset %d\n",
sctp_rr_request->send_alignment,
sctp_rr_request->send_offset);
fflush(where);
}
/* at some point, these need to come to us from the remote system */
if (send_width == 0) send_width = 1;
if (recv_width == 0) recv_width = 1;
send_ring = allocate_buffer_ring(send_width,
sctp_rr_request->response_size,
sctp_rr_request->send_alignment,
sctp_rr_request->send_offset);
recv_ring = allocate_buffer_ring(recv_width,
sctp_rr_request->request_size,
sctp_rr_request->recv_alignment,
sctp_rr_request->recv_offset);
/* create_data_socket expects to find some things in the global */
/* variables, so set the globals based on the values in the request. */
/* once the socket has been created, we will set the response values */
/* based on the updated value of those globals. raj 7/94 */
lss_size_req = sctp_rr_request->send_buf_size;
lsr_size_req = sctp_rr_request->recv_buf_size;
loc_nodelay = sctp_rr_request->no_delay;
loc_rcvavoid = sctp_rr_request->so_rcvavoid;
loc_sndavoid = sctp_rr_request->so_sndavoid;
non_block = sctp_rr_request->non_blocking;
set_hostname_and_port(local_name,
port_buffer,
nf_to_af(sctp_rr_request->ipfamily),
sctp_rr_request->port);
local_res = complete_addrinfo(local_name,
local_name,
port_buffer,
nf_to_af(sctp_rr_request->ipfamily),
SOCK_SEQPACKET,
IPPROTO_SCTP,
0);
/* Grab a socket to listen on, and then listen on it. */
if (debug) {
fprintf(where,"recv_sctp_rr_1toMany: grabbing a socket...\n");
fflush(where);
}
s_rcv = create_data_socket(local_res);
if (s_rcv < 0) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
/* Now, let's set-up the socket to listen for connections */
if (listen(s_rcv, 5) == -1) {
netperf_response.content.serv_errno = errno;
close(s_rcv);
send_response();
exit(1);
}
/* now get the port number assigned by the system */
addrlen = sizeof(myaddr_in);
if (getsockname(s_rcv,
(struct sockaddr *)&myaddr_in, &addrlen) == -1){
netperf_response.content.serv_errno = errno;
close(s_rcv);
send_response();
exit(1);
}
/* Now myaddr_in contains the port and the internet address this is */
/* returned to the sender also implicitly telling the sender that the */
/* socket buffer sizing has been done. */
sctp_rr_response->data_port_number = (int) ntohs(myaddr_in.sin_port);
netperf_response.content.serv_errno = 0;
/* But wait, there's more. If the initiator wanted cpu measurements, */
/* then we must call the calibrate routine, which will return the max */
/* rate back to the initiator. If the CPU was not to be measured, or */
/* something went wrong with the calibration, we will return a 0.0 to */
/* the initiator. */
sctp_rr_response->cpu_rate = (float)0.0; /* assume no cpu */
sctp_rr_response->measure_cpu = 0;
if (sctp_rr_request->measure_cpu) {
sctp_rr_response->measure_cpu = 1;
sctp_rr_response->cpu_rate = calibrate_local_cpu(sctp_rr_request->cpu_rate);
}
/* before we send the response back to the initiator, pull some of */
/* the socket parms from the globals */
sctp_rr_response->send_buf_size = lss_size;
sctp_rr_response->recv_buf_size = lsr_size;
sctp_rr_response->no_delay = loc_nodelay;
sctp_rr_response->so_rcvavoid = loc_rcvavoid;
sctp_rr_response->so_sndavoid = loc_sndavoid;
sctp_rr_response->test_length = sctp_rr_request->test_length;
send_response();
/* Don't need events */
sctp_enable_events(s_rcv, 0);
/* now that we are connected, mark the socket as non-blocking */
if (non_block) {
if (!set_nonblock(s_rcv)) {
perror("netperf: set_nonblock");
exit(1);
}
}
/* FIXME: The way 1-to-Many test operates right now, we are including
* association setup time into our measurements. The reason for this
* is that the client creates multiple endpoints and connects each
* endpoint to us using the connect call. On this end we simply call
* recvmsg() to get data becuase there is no equivalen of accept() for
* 1-to-Many API.
* I think this is OK, but if it were to be fixed, the server side
* would need to know how many associations are being setup and
* have a recvmsg() loop with SCTP_ASSOC_CHANGE events waiting for
* all the associations to be be established.
* I am punting on this for now.
*/
addrlen = sizeof(peeraddr);
/* Now it's time to start receiving data on the connection. We will */
/* first grab the apropriate counters and then start grabbing. */
cpu_start(sctp_rr_request->measure_cpu);
/* The loop will exit when we hit the end of the test time, or when */
/* we have exchanged the requested number of transactions. */
if (sctp_rr_request->test_length > 0) {
times_up = 0;
trans_remaining = 0;
start_timer(sctp_rr_request->test_length + PAD_TIME);
}
else {
times_up = 1;
trans_remaining = sctp_rr_request->test_length * -1;
}
trans_received = 0;
while ((!times_up) || (trans_remaining > 0)) {
recv_buf_size = sctp_rr_request->request_size;
/* Receive the data. We don't particularly care which association
* the data came in on. We'll simply be doing a receive untill
* we get and MSG_EOR flag (meaning that a single transmission was
* received) and a send to the same address, so the RR would be for
* the same associations.
* We can get away with this because the client will establish all
* the associations before transmitting any data. Any partial data
* will not have EOR thus will we will not send a response untill
* we get everything.
*/
do {
msg_flags = 0;
if((bytes_recvd = sctp_recvmsg(s_rcv,
recv_ring->buffer_ptr,
recv_buf_size,
(struct sockaddr *)&peeraddr, &addrlen,
0, &msg_flags)) == SOCKET_ERROR) {
if (SOCKET_EINTR(bytes_recvd)) {
/* the timer popped */
timed_out = 1;
break;
} else if (non_block & errno == EAGAIN) {
/* do recvmsg again */
continue;
}
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
} while(!(msg_flags & MSG_EOR));
recv_ring = recv_ring->next;
if (timed_out) {
/* we hit the end of the test based on time - lets */
/* bail out of here now... */
if (debug) {
fprintf(where,"yo5\n");
fflush(where);
}
break;
}
/* Now, send the response to the remote */
while ((bytes_sent=sctp_sendmsg(s_rcv,
send_ring->buffer_ptr,
sctp_rr_request->response_size,
(struct sockaddr *)&peeraddr, addrlen,
0, 0, 0, 0, 0)) == SOCKET_ERROR) {
if (SOCKET_EINTR(bytes_sent)) {
/* the test timer has popped */
timed_out = 1;
break;
} else if (non_block && errno == EAGAIN) {
continue;
}
netperf_response.content.serv_errno = 992;
send_response();
exit(1);
}
if (timed_out) {
if (debug) {
fprintf(where,"yo6\n");
fflush(where);
}
/* we hit the end of the test based on time - lets */
/* bail out of here now... */
break;
}
send_ring = send_ring->next;
trans_received++;
if (trans_remaining) {
trans_remaining--;
}
}
/* The loop now exits due to timeout or transaction count being */
/* reached */
cpu_stop(sctp_rr_request->measure_cpu,&elapsed_time);
stop_timer();
if (timed_out) {
/* we ended the test by time, which was at least 2 seconds */
/* longer than we wanted to run. so, we want to subtract */
/* PAD_TIME from the elapsed_time. */
elapsed_time -= PAD_TIME;
}
/* send the results to the sender */
if (debug) {
fprintf(where,
"recv_sctp_rr: got %d transactions\n",
trans_received);
fflush(where);
}
sctp_rr_results->bytes_received = (trans_received *
(sctp_rr_request->request_size +
sctp_rr_request->response_size));
sctp_rr_results->trans_received = trans_received;
sctp_rr_results->elapsed_time = elapsed_time;
sctp_rr_results->cpu_method = cpu_method;
sctp_rr_results->num_cpus = lib_num_loc_cpus;
if (sctp_rr_request->measure_cpu) {
sctp_rr_results->cpu_util = calc_cpu_util(elapsed_time);
}
if (debug) {
fprintf(where,
"recv_sctp_rr: test complete, sending results.\n");
fflush(where);
}
/* we are now done with the sockets */
close(s_rcv);
send_response();
}
void
print_sctp_usage()
{
printf("%s",sctp_usage);
exit(1);
}
void
scan_sctp_args(argc, argv)
int argc;
char *argv[];
{
#define SOCKETS_ARGS "BDhH:I:L:m:M:P:r:s:S:VN:T:46"
extern char *optarg; /* pointer to option string */
int c;
char
arg1[BUFSIZ], /* argument holders */
arg2[BUFSIZ];
if (no_control) {
fprintf(where,
"The SCTP tests do not know how to deal with no control tests\n");
exit(-1);
}
strncpy(local_data_port,"0",sizeof(local_data_port));
strncpy(remote_data_port,"0",sizeof(remote_data_port));
/* Go through all the command line arguments and break them */
/* out. For those options that take two parms, specifying only */
/* the first will set both to that value. Specifying only the */
/* second will leave the first untouched. To change only the */
/* first, use the form "first," (see the routine break_args.. */
while ((c= getopt(argc, argv, SOCKETS_ARGS)) != EOF) {
switch (c) {
case '?':
case '4':
remote_data_family = AF_INET;
local_data_family = AF_INET;
break;
case '6':
#if defined(AF_INET6)
remote_data_family = AF_INET6;
local_data_family = AF_INET6;
#else
fprintf(stderr,
"This netperf was not compiled on an IPv6 capable host!\n");
fflush(stderr);
exit(-1);
#endif
break;
case 'h':
print_sctp_usage();
exit(1);
case 'b':
#ifdef WANT_FIRST_BURST
first_burst_size = atoi(optarg);
#else /* WANT_FIRST_BURST */
printf("Initial request burst functionality not compiled-in!\n");
#endif /* WANT_FIRST_BURST */
break;
case 'D':
/* set the nodelay flag */
loc_nodelay = 1;
rem_nodelay = 1;
break;
case 'H':
break_args_explicit(optarg,arg1,arg2);
if (arg1[0]) {
/* make sure we leave room for the NULL termination boys and
girls. raj 2005-02-82 */
remote_data_address = malloc(strlen(arg1)+1);
strncpy(remote_data_address,arg1,strlen(arg1));
}
if (arg2[0])
remote_data_family = parse_address_family(arg2);
break;
case 'L':
break_args_explicit(optarg,arg1,arg2);
if (arg1[0]) {
/* make sure we leave room for the NULL termination boys and
girls. raj 2005-02-82 */
local_data_address = malloc(strlen(arg1)+1);
strncpy(local_data_address,arg1,strlen(arg1));
}
if (arg2[0])
local_data_family = parse_address_family(arg2);
break;
case 'P':
/* set the local and remote data port numbers for the tests to
allow them to run through those blankety blank end-to-end
breaking firewalls. raj 2004-06-15 */
break_args(optarg,arg1,arg2);
if (arg1[0])
strncpy(local_data_port,arg1,sizeof(local_data_port));
if (arg2[0])
strncpy(remote_data_port,arg2,sizeof(remote_data_port));
break;
case 's':
/* set local socket sizes */
break_args(optarg,arg1,arg2);
if (arg1[0])
lss_size_req = convert(arg1);
if (arg2[0])
lsr_size_req = convert(arg2);
break;
case 'S':
/* set remote socket sizes */
break_args(optarg,arg1,arg2);
if (arg1[0])
rss_size_req = convert(arg1);
if (arg2[0])
rsr_size_req = convert(arg2);
break;
case 'r':
/* set the request/response sizes */
break_args(optarg,arg1,arg2);
if (arg1[0])
req_size = convert(arg1);
if (arg2[0])
rsp_size = convert(arg2);
break;
case 'm':
/* set size of the buffer for each sent message */
send_size = convert(optarg);
break;
case 'M':
/* set the size of the buffer for each received message */
recv_size = convert(optarg);
break;
case 't':
/* set the test name */
strcpy(test_name,optarg);
break;
case 'W':
/* set the "width" of the user space data */
/* buffer. This will be the number of */
/* send_size buffers malloc'd in the */
/* *_STREAM test. It may be enhanced to set */
/* both send and receive "widths" but for now */
/* it is just the sending *_STREAM. */
send_width = convert(optarg);
break;
case 'V':
/* we want to do copy avoidance and will set */
/* it for everything, everywhere, if we really */
/* can. of course, we don't know anything */
/* about the remote... */
#ifdef SO_SND_COPYAVOID
loc_sndavoid = 1;
#else
loc_sndavoid = 0;
printf("Local send copy avoidance not available.\n");
#endif
#ifdef SO_RCV_COPYAVOID
loc_rcvavoid = 1;
#else
loc_rcvavoid = 0;
printf("Local recv copy avoidance not available.\n");
#endif
rem_sndavoid = 1;
rem_rcvavoid = 1;
break;
case 'N':
/* this opton allows the user to set the number of
* messages to send. This in effect modifies the test
* time. If we know the message size, then the we can
* express the test time as message_size * number_messages
*/
msg_count = convert (optarg);
if (msg_count > 0)
test_time = 0;
break;
case 'B':
non_block = 1;
break;
case 'T':
num_associations = atoi(optarg);
if (num_associations <= 1) {
printf("Number of SCTP associations must be >= 1\n");
exit(1);
}
break;
};
}
}
#endif /* WANT_SCTP */