[netperf-dev] netperf2 commit notice r524 - trunk/src
raj at netperf.org
raj at netperf.org
Tue Jan 31 14:19:03 PST 2012
Author: raj
Date: 2012-01-31 14:19:03 -0800 (Tue, 31 Jan 2012)
New Revision: 524
Modified:
trunk/src/nettest_unix.c
Log:
various neatenings in the unix domain socket code
Modified: trunk/src/nettest_unix.c
===================================================================
--- trunk/src/nettest_unix.c 2012-01-31 21:42:45 UTC (rev 523)
+++ trunk/src/nettest_unix.c 2012-01-31 22:19:03 UTC (rev 524)
@@ -15,7 +15,7 @@
#ifdef WANT_UNIX
char nettest_unix_id[]="\
@(#)nettest_unix.c (c) Copyright 1994-2012 Hewlett-Packard Co. Version post-2.5.0-tot";
-
+
/****************************************************************/
/* */
/* nettest_bsd.c */
@@ -38,26 +38,20 @@
/* rem_cpu_rate() find the remote cpu maxrate */
/* */
/****************************************************************/
-
- /* at some point, I might want to go-in and see if I really need all */
- /* these includes, but for the moment, we'll let them all just sit */
- /* there. raj 8/94 */
+
+ /* at some point, I might want to go-in and see if I really need all
+ these includes, but for the moment, we'll let them all just sit
+ there. raj 8/94 */
#include <sys/types.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
-#ifndef WIN32
#include <sys/ipc.h>
#include <sys/socket.h>
#include <errno.h>
#include <signal.h>
#include <sys/un.h>
#include <unistd.h>
-#else /* WIN32 */
-#include <process.h>
-#include <winsock2.h>
-#include <windows.h>
-#endif /* WIN32 */
#include <string.h>
#include <time.h>
#include <sys/time.h>
@@ -70,24 +64,24 @@
#include <sys/stat.h>
-
+
#include "netlib.h"
#include "netsh.h"
#include "nettest_unix.h"
- /* these variables are specific to the UNIX sockets tests. declare */
- /* them static to make them global only to this file. */
+/* these variables are specific to the UNIX sockets tests. declare
+ them static to make them global only to this file. */
#define UNIX_PRFX "netperf."
#define UNIX_LENGTH_MAX 0xFFFF - 28
static char
- path_prefix[32];
+ path_prefix[32];
static int
- rss_size, /* remote socket send buffer size */
+ rss_size, /* remote socket send buffer size */
rsr_size, /* remote socket recv buffer size */
lss_size_req, /* requested local socket send buffer size */
lsr_size_req, /* requested local socket recv buffer size */
@@ -118,9 +112,9 @@
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";
+comma.\n";
- /* this routing initializes all the test specific variables */
+/* this routing initializes all the test specific variables */
static void
init_test_vars()
@@ -138,15 +132,15 @@
strcpy(path_prefix,"/tmp");
-}
+}
- /* This routine will create a data (listen) socket with the apropriate */
- /* options set and return it to the caller. this replaces all the */
- /* duplicate code in each of the test routines and should help make */
- /* things a little easier to understand. since this routine can be */
- /* called by either the netperf or netserver programs, all output */
- /* should be directed towards "where." family is generally AF_UNIX, */
- /* and type will be either SOCK_STREAM or SOCK_DGRAM */
+/* This routine will create a data (listen) socket with the apropriate
+ options set and return it to the caller. this replaces all the
+ duplicate code in each of the test routines and should help make
+ things a little easier to understand. since this routine can be
+ called by either the netperf or netserver programs, all output
+ should be directed towards "where." family is generally AF_UNIX,
+ and type will be either SOCK_STREAM or SOCK_DGRAM */
SOCKET
create_unix_socket(int family, int type)
{
@@ -154,10 +148,10 @@
SOCKET temp_socket;
/*set up the data socket */
- temp_socket = socket(family,
+ temp_socket = socket(family,
type,
0);
-
+
if (temp_socket == INVALID_SOCKET){
fprintf(where,
"netperf: create_unix_socket: socket: %d\n",
@@ -165,25 +159,26 @@
fflush(where);
exit(1);
}
-
+
if (debug) {
fprintf(where,"create_unix_socket: socket %d obtained...\n",temp_socket);
fflush(where);
}
-
- /* Modify the local socket size. The reason we alter the send buffer */
- /* size here rather than when the connection is made is to take care */
- /* of decreases in buffer size. Decreasing the window size after */
- /* connection establishment is a STREAM no-no. Also, by setting the */
- /* buffer (window) size before the connection is established, we can */
- /* control the STREAM MSS (segment size). The MSS is never more that 1/2 */
- /* the minimum receive buffer size at each half of the connection. */
- /* This is why we are altering the receive buffer size on the sending */
- /* size of a unidirectional transfer. If the user has not requested */
- /* that the socket buffers be altered, we will try to find-out what */
- /* their values are. If we cannot touch the socket buffer in any way, */
- /* we will set the values to -1 to indicate that. */
-
+
+ /* Modify the local socket size. The reason we alter the send buffer
+ size here rather than when the connection is made is to take care
+ of decreases in buffer size. Decreasing the window size after
+ connection establishment is a STREAM no-no. Also, by setting the
+ buffer (window) size before the connection is established, we can
+ control the STREAM MSS (segment size). The MSS is never more that
+ 1/2 the minimum receive buffer size at each half of the
+ connection. This is why we are altering the receive buffer size
+ on the sending size of a unidirectional transfer. If the user has
+ not requested that the socket buffers be altered, we will try to
+ find-out what their values are. If we cannot touch the socket
+ buffer in any way, we will set the values to -1 to indicate
+ that. */
+
set_sock_buffer(temp_socket, SEND_BUFFER, lss_size_req, &lss_size);
set_sock_buffer(temp_socket, RECV_BUFFER, lsr_size_req, &lsr_size);
@@ -192,108 +187,108 @@
}
-/* This routine implements the STREAM 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. */
+/* This routine implements the STREAM 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
+void
send_stream_stream(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 =
"%5d %5d %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 %% %% us/KB us/KB\n\n";
-
+
char *cpu_fmt_0 =
"%6.3f\n";
-
+
char *cpu_fmt_1 =
"%5d %5d %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";
-
-
+
+
float elapsed_time;
-
+
#ifdef WANT_INTERVALS
int interval_count;
#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. */
-
+
+ /* 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
#include <sys/stat.h>
struct ring_elt *send_ring;
-
+
int len = 0;
int nummessages;
SOCKET send_socket;
int bytes_remaining;
- /* with links like fddi, one can send > 32 bits worth of bytes */
- /* during a test... ;-) */
+ /* with links like fddi, one can send > 32 bits worth of bytes
+ during a test... ;-) */
double bytes_sent;
-
+
#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 sockaddr_un server;
-
+
struct stream_stream_request_struct *stream_stream_request;
struct stream_stream_response_struct *stream_stream_response;
struct stream_stream_results_struct *stream_stream_result;
-
- stream_stream_request =
+
+ stream_stream_request =
(struct stream_stream_request_struct *)netperf_request.content.test_specific_data;
stream_stream_response =
(struct stream_stream_response_struct *)netperf_response.content.test_specific_data;
- stream_stream_result =
+ stream_stream_result =
(struct stream_stream_results_struct *)netperf_response.content.test_specific_data;
-
- /* 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. */
-
+
+ /* 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. */
+
bzero((char *)&server,
sizeof(server));
server.sun_family = AF_UNIX;
-
-
+
+
if ( print_headers ) {
fprintf(where,"STREAM STREAM TEST\n");
if (local_cpu_usage || remote_cpu_usage)
@@ -301,32 +296,32 @@
else
fprintf(where,tput_title,format_units());
}
-
+
/* initialize a few counters */
-
+
nummessages = 0;
bytes_sent = 0.0;
times_up = 0;
-
+
/*set up the data socket */
- send_socket = create_unix_socket(AF_UNIX,
+ send_socket = create_unix_socket(AF_UNIX,
SOCK_STREAM);
-
+
if (send_socket == INVALID_SOCKET){
perror("netperf: send_stream_stream: stream stream data socket");
exit(1);
}
-
+
if (debug) {
fprintf(where,"send_stream_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... */
+
+ /* 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;
@@ -335,44 +330,44 @@
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... */
+
+ /* 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++;
}
-
+
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 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. */
-
+
+ /* 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_STREAM_STREAM;
stream_stream_request->send_buf_size = rss_size;
stream_stream_request->recv_buf_size = rsr_size;
@@ -391,27 +386,27 @@
stream_stream_request->dirty_count = rem_dirty_count;
stream_stream_request->clean_count = rem_clean_count;
#endif /* DIRTY */
-
-
+
+
if (debug > 1) {
fprintf(where,
"netperf: send_stream_stream: requesting STREAM 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 STREAM tests. */
-
+
+ /* 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 STREAM tests. */
+
recv_response();
-
+
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote listen done.\n");
@@ -426,25 +421,25 @@
perror("netperf: send_stream_stream: remote error");
exit(1);
}
-
+
/*Connect up to the remote port on the data socket */
- if (connect(send_socket,
+ if (connect(send_socket,
(struct sockaddr *)&server,
sizeof(server)) == INVALID_SOCKET){
perror("netperf: send_stream_stream: data socket connect failed");
printf(" path: %s\n",server.sun_path);
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. */
-
+
+ /* 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;
@@ -456,34 +451,35 @@
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. */
-
+
+ /* 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);
-
- /* 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. */
-
+
+ /* 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. */
+
#ifdef DIRTY
- /* initialize the random number generator for putting dirty stuff */
- /* into the send buffer. raj */
+ /* initialize the random number generator for putting dirty stuff
+ into the send buffer. raj */
srand((int) getpid());
#endif
-
+
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. */
+ /* 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();
@@ -494,7 +490,7 @@
message_int_ptr++;
}
#endif /* DIRTY */
-
+
if((len=send(send_socket,
send_ring->buffer_ptr,
send_size,
@@ -512,40 +508,39 @@
interval_count < interval_wate;
interval_count++);
#endif
-
- /* 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++;
+
+ /* 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. */
-
+
+ /* 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. */
+
if (close(send_socket) == -1) {
perror("netperf: send_stream_stream: cannot close socket");
exit(1);
}
-
- /* 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? */
-
- /* 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. */
-
+
+ /* 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? */
+
+ /* 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)
@@ -554,28 +549,29 @@
else {
Set_errno(netperf_response.content.serv_errno);
perror("netperf: remote error");
-
+
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 STREAM 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 ;-) */
-
+
+ /* 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
+ STREAM 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 = ((double) send_size * (double) nummessages) + len;
thruput = 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...*/
+ /* 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) {
if (local_cpu_rate == 0.0) {
fprintf(where,"WARNING WARNING WARNING WARNING WARNING WARNING WARNING!\n");
@@ -592,7 +588,7 @@
local_cpu_utilization = -1.0;
local_service_demand = -1.0;
}
-
+
if (remote_cpu_usage) {
if (remote_cpu_rate == 0.0) {
fprintf(where,"DANGER DANGER DANGER DANGER DANGER DANGER DANGER!\n");
@@ -609,16 +605,16 @@
remote_cpu_utilization = -1.0;
remote_service_demand = -1.0;
}
-
- /* 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... */
-
+
+ /* 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... */
+
switch (verbosity) {
case 0:
if (local_cpu_usage) {
@@ -659,28 +655,28 @@
case 1:
case 2:
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 */
+ 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. */
-
+
+ /* 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 */
- /* STREAM statistics, the alignments of the sends and receives */
- /* and all that sort of rot... */
-
+ /* 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
+ STREAM statistics, the alignments of the sends and receives and
+ all that sort of rot... */
+
fprintf(where,
ksink_fmt,
"Bytes",
@@ -696,18 +692,18 @@
bytes_sent / (double)stream_stream_result->recv_calls,
stream_stream_result->recv_calls);
}
-
+
}
-/* This is the server-side routine for the stream stream test. It is */
-/* implemented as one routine. I could break things-out somewhat, but */
-/* didn't feel it was necessary. */
+/* This is the server-side routine for the stream stream test. It is
+ implemented as one routine. I could break things-out somewhat, but
+ didn't feel it was necessary. */
void
recv_stream_stream()
{
-
+
struct sockaddr_un myaddr_un, peeraddr_un;
SOCKET s_listen,s_data;
netperf_socklen_t addrlen;
@@ -715,7 +711,7 @@
int receive_calls = 0;
float elapsed_time;
int bytes_received;
-
+
struct ring_elt *recv_ring;
#ifdef DIRTY
@@ -725,95 +721,95 @@
int clean_count;
int i;
#endif
-
+
struct stream_stream_request_struct *stream_stream_request;
struct stream_stream_response_struct *stream_stream_response;
struct stream_stream_results_struct *stream_stream_results;
-
- stream_stream_request =
+
+ stream_stream_request =
(struct stream_stream_request_struct *)netperf_request.content.test_specific_data;
- stream_stream_response =
+ stream_stream_response =
(struct stream_stream_response_struct *)netperf_response.content.test_specific_data;
- stream_stream_results =
+ stream_stream_results =
(struct stream_stream_results_struct *)netperf_response.content.test_specific_data;
-
+
if (debug) {
fprintf(where,"netserver: recv_stream_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. */
-
+
+ /* 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_stream_stream: setting the response type...\n");
fflush(where);
}
-
+
netperf_response.content.response_type = STREAM_STREAM_RESPONSE;
-
+
if (debug) {
fprintf(where,"recv_stream_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. */
-
+
+ /* We now alter the message_ptr variable to be at the desired
+ alignment with the desired offset. */
+
if (debug) {
fprintf(where,"recv_stream_stream: requested alignment of %d\n",
stream_stream_request->recv_alignment);
fflush(where);
}
- /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
- /* can put in OUR values !-) At some point, we may want to nail this */
- /* socket to a particular network-level address, but for now, */
- /* INADDR_ANY should be just fine. */
-
+ /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
+ can put in OUR values !-) At some point, we may want to nail this
+ socket to a particular network-level address, but for now,
+ INADDR_ANY should be just fine. */
+
bzero((char *)&myaddr_un,
sizeof(myaddr_un));
myaddr_un.sun_family = AF_UNIX;
-
+
/* Grab a socket to listen on, and then listen on it. */
-
+
if (debug) {
fprintf(where,"recv_stream_stream: grabbing a socket...\n");
fflush(where);
}
-
- /* create_unix_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 */
+
+ /* create_unix_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 = stream_stream_request->send_buf_size;
lsr_size_req = stream_stream_request->recv_buf_size;
s_listen = create_unix_socket(AF_UNIX,
SOCK_STREAM);
-
+
if (s_listen == INVALID_SOCKET) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
-
- /* Let's get an address assigned to this socket so we can tell the */
- /* initiator how to reach the data socket. There may be a desire to */
- /* nail this socket to a specific IP address in a multi-homed, */
- /* multi-connection situation, but for now, we'll ignore the issue */
- /* and concentrate on single connection testing. */
-
+
+ /* Let's get an address assigned to this socket so we can tell the
+ initiator how to reach the data socket. There may be a desire to
+ nail this socket to a specific IP address in a multi-homed,
+ multi-connection situation, but for now, we'll ignore the issue
+ and concentrate on single connection testing. */
+
strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
if (debug) {
fprintf(where,"selected a path of %s\n",myaddr_un.sun_path);
@@ -826,10 +822,10 @@
fprintf(where,"could not bind to path\n");
close(s_listen);
send_response();
-
+
exit(1);
}
-
+
chmod(myaddr_un.sun_path, 0666);
/* what sort of sizes did we end-up with? */
@@ -844,14 +840,14 @@
else {
recv_size = stream_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 */
+ /* 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++;
@@ -866,57 +862,57 @@
fprintf(where,"recv_stream_stream: receive alignment and offset set...\n");
fflush(where);
}
-
+
/* Now, let's set-up the socket to listen for connections */
if (listen(s_listen, 5) == SOCKET_ERROR) {
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_un);
- if (getsockname(s_listen,
+ if (getsockname(s_listen,
(struct sockaddr *)&myaddr_un,
&addrlen) == SOCKET_ERROR){
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
-
+
exit(1);
}
-
- /* Now myaddr_un contains the path */
- /* returned to the sender also implicitly telling the sender that the */
- /* socket buffer sizing has been done. */
+
+ /* Now myaddr_un contains the path returned to the sender also
+ implicitly telling the sender that the socket buffer sizing has
+ been done. */
strcpy(stream_stream_response->unix_path,myaddr_un.sun_path);
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. */
-
+
+ /* 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. */
+
stream_stream_response->cpu_rate = 0.0; /* assume no cpu */
if (stream_stream_request->measure_cpu) {
stream_stream_response->measure_cpu = 1;
- stream_stream_response->cpu_rate =
+ stream_stream_response->cpu_rate =
calibrate_local_cpu(stream_stream_request->cpu_rate);
}
-
- /* before we send the response back to the initiator, pull some of */
- /* the socket parms from the globals */
+
+ /* before we send the response back to the initiator, pull some of
+ the socket parms from the globals */
stream_stream_response->send_buf_size = lss_size;
stream_stream_response->recv_buf_size = lsr_size;
stream_stream_response->receive_size = recv_size;
send_response();
-
+
addrlen = sizeof(peeraddr_un);
-
+
if ((s_data=accept(s_listen,
(struct sockaddr *)&peeraddr_un,
&addrlen)) == INVALID_SOCKET) {
@@ -924,20 +920,20 @@
close(s_listen);
exit(1);
}
-
- /* Now it's time to start receiving data on the connection. We will */
- /* first grab the apropriate counters and then start grabbing. */
-
+
+ /* Now it's time to start receiving data on the connection. We will
+ first grab the apropriate counters and then start grabbing. */
+
cpu_start(stream_stream_request->measure_cpu);
-
- /* The loop will exit when the sender does a shutdown, which will */
- /* return a length of zero */
-
+
+ /* 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. */
+ /* 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 = stream_stream_request->dirty_count;
clean_count = stream_stream_request->clean_count;
@@ -977,25 +973,25 @@
}
#endif /* DIRTY */
}
-
- /* The loop now exits due to zero bytes received. we will have */
- /* counted one too many messages received, so decrement the */
- /* receive_calls counter by one. raj 7/94 */
+
+ /* The loop now exits due to zero bytes received. we will have
+ counted one too many messages received, so decrement the
+ receive_calls counter by one. raj 7/94 */
receive_calls--;
-
- /* perform a shutdown to signal the sender that */
- /* we have received all the data sent. raj 4/93 */
+ /* perform a shutdown to signal the sender that we have received all
+ the data sent. raj 4/93 */
+
if (shutdown(s_data,1) == SOCKET_ERROR) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
-
+
cpu_stop(stream_stream_request->measure_cpu,&elapsed_time);
-
+
/* send the results to the sender */
-
+
if (debug) {
fprintf(where,
"recv_stream_stream: got %d bytes\n",
@@ -1005,72 +1001,72 @@
receive_calls);
fflush(where);
}
-
+
stream_stream_results->bytes_received = bytes_received;
stream_stream_results->elapsed_time = elapsed_time;
stream_stream_results->recv_calls = receive_calls;
-
+
if (stream_stream_request->measure_cpu) {
stream_stream_results->cpu_util = calc_cpu_util(0.0);
};
-
+
if (debug > 1) {
fprintf(where,
"recv_stream_stream: test complete, sending results.\n");
fflush(where);
}
-
+
send_response();
unlink(myaddr_un.sun_path);
}
- /* this routine implements the sending (netperf) side of the STREAM_RR */
- /* test. */
+/* this routine implements the sending (netperf) side of the STREAM_RR
+ test. */
void
send_stream_rr(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 %% %% us/Tr us/Tr\n\n";
-
+
char *cpu_fmt_0 =
"%6.3f\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;
@@ -1080,40 +1076,40 @@
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_un server;
-
+
struct stream_rr_request_struct *stream_rr_request;
struct stream_rr_response_struct *stream_rr_response;
struct stream_rr_results_struct *stream_rr_result;
-
- stream_rr_request =
+
+ stream_rr_request =
(struct stream_rr_request_struct *)netperf_request.content.test_specific_data;
stream_rr_response=
(struct stream_rr_response_struct *)netperf_response.content.test_specific_data;
stream_rr_result =
(struct stream_rr_results_struct *)netperf_response.content.test_specific_data;
-
- /* 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. */
-
+
+ /* 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. */
+
bzero((char *)&server,
sizeof(server));
-
+
server.sun_family = AF_UNIX;
-
-
+
+
if ( print_headers ) {
fprintf(where,"STREAM REQUEST/RESPONSE TEST\n");
if (local_cpu_usage || remote_cpu_usage)
@@ -1121,20 +1117,20 @@
else
fprintf(where,tput_title,format_units());
}
-
+
/* initialize a few counters */
-
+
nummessages = 0;
bytes_xferd = 0.0;
times_up = 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 */
+ /* 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;
-
+
send_ring = allocate_buffer_ring(send_width,
req_size,
local_send_align,
@@ -1144,39 +1140,39 @@
rsp_size,
local_recv_align,
local_recv_offset);
-
+
/*set up the data socket */
- send_socket = create_unix_socket(AF_UNIX,
+ send_socket = create_unix_socket(AF_UNIX,
SOCK_STREAM);
-
+
if (send_socket == INVALID_SOCKET){
perror("netperf: send_stream_rr: stream stream data socket");
exit(1);
}
-
+
if (debug) {
fprintf(where,"send_stream_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 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. */
-
+
+ /* 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_STREAM_RR;
stream_rr_request->recv_buf_size = rsr_size;
stream_rr_request->send_buf_size = rss_size;
@@ -1194,25 +1190,25 @@
else {
stream_rr_request->test_length = test_trans * -1;
}
-
+
if (debug > 1) {
fprintf(where,"netperf: send_stream_rr: requesting STREAM 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 STREAM tests. */
-
+
+ /* 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 STREAM tests. */
+
recv_response();
-
+
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote listen done.\n");
@@ -1226,28 +1222,28 @@
else {
Set_errno(netperf_response.content.serv_errno);
perror("netperf: remote error");
-
+
exit(1);
}
-
+
/*Connect up to the remote port on the data socket */
- if (connect(send_socket,
+ if (connect(send_socket,
(struct sockaddr *)&server,
sizeof(server)) == INVALID_SOCKET){
perror("netperf: data socket connect failed");
-
+
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. */
-
+
+ /* 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;
@@ -1259,31 +1255,32 @@
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. */
-
+
+ /* 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);
-
- /* 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. */
-
+
+ /* 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. */
+
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. */
+ /* send the request. we assume that if we use a blocking socket,
+ the request will be sent at one shot. */
if((len=send(send_socket,
send_ring->buffer_ptr,
req_size,
0)) != req_size) {
if (errno == EINTR) {
- /* we hit the end of a */
+ /* we hit the end of a
/* timed test. */
timed_out = 1;
break;
@@ -1292,7 +1289,7 @@
exit(1);
}
send_ring = send_ring->next;
-
+
/* receive the response */
rsp_bytes_left = rsp_size;
temp_message_ptr = recv_ring->buffer_ptr;
@@ -1313,18 +1310,18 @@
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. */
+ /* we may have been in a nested while loop - we need
+ another call to break. */
break;
}
-
- nummessages++;
+
+ nummessages++;
if (trans_remaining) {
trans_remaining--;
}
-
+
if (debug > 3) {
fprintf(where,
"Transaction %d completed\n",
@@ -1332,24 +1329,26 @@
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 service demand and all those interesting things. If it */
- /* wasn't supposed to care, it will return obvious values. */
-
+
+ /* 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 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)
@@ -1358,31 +1357,31 @@
else {
Set_errno(netperf_response.content.serv_errno);
perror("netperf: remote error");
-
+
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 STREAM 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 ;-) We use */
- /* Kbytes/s as the units of thruput for a STREAM stream test, where K = */
- /* 1024. A future enhancement *might* be to choose from a couple of */
- /* unit selections. */
-
+
+ /* 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
+ STREAM 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 ;-) We use Kbytes/s as the units of thruput for a
+ STREAM stream test, where K = 1024. A future enhancement *might*
+ be to choose from a couple of unit selections. */
+
bytes_xferd = (req_size * nummessages) + (rsp_size * nummessages);
thruput = calc_thruput(bytes_xferd);
-
+
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...*/
+ /* 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) {
if (local_cpu_rate == 0.0) {
fprintf(where,"WARNING WARNING WARNING WARNING WARNING WARNING WARNING!\n");
@@ -1390,9 +1389,8 @@
fflush(where);
}
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 */
+ /* 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,
@@ -1402,7 +1400,7 @@
local_cpu_utilization = -1.0;
local_service_demand = -1.0;
}
-
+
if (remote_cpu_usage) {
if (remote_cpu_rate == 0.0) {
fprintf(where,"DANGER DANGER DANGER DANGER DANGER DANGER DANGER!\n");
@@ -1410,9 +1408,8 @@
fflush(where);
}
remote_cpu_utilization = stream_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 */
+ /* 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,
@@ -1422,16 +1419,16 @@
remote_cpu_utilization = -1.0;
remote_service_demand = -1.0;
}
-
- /* 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... */
-
+
+ /* 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... */
+
switch (verbosity) {
case 0:
if (local_cpu_usage) {
@@ -1486,87 +1483,87 @@
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. */
-
+
+ /* 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 */
- /* STREAM statistics, the alignments of the sends and receives */
- /* and all that sort of rot... */
-
+ /* 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
+ STREAM statistics, the alignments of the sends and receives and
+ all that sort of rot... */
+
fprintf(where,
"%s",
ksink_fmt);
}
/* The test is over. Kill the data socket */
-
+
if (close(send_socket) == -1) {
perror("send_stream_rr: cannot shutdown stream stream socket");
}
-
+
}
void
send_dg_stream(char remote_host[])
{
- /************************************************************************/
- /* */
+ /*********************************************************************/
+ /* */
/* DG Unidirectional Send Test */
- /* */
- /************************************************************************/
+ /* */
+ /*********************************************************************/
char *tput_title =
"Socket Message Elapsed Messages \n\
Size Size Time Okay Errors Throughput\n\
bytes bytes secs # # %s/sec\n\n";
-
+
char *tput_fmt_0 =
"%7.2f\n";
-
+
char *tput_fmt_1 =
"%5d %5d %-7.2f %7d %6d %7.2f\n\
%5d %-7.2f %7d %7.2f\n\n";
-
-
+
+
char *cpu_title =
"Socket Message Elapsed Messages CPU Service\n\
Size Size Time Okay Errors Throughput Util Demand\n\
bytes bytes secs # # %s/sec %% us/KB\n\n";
-
+
char *cpu_fmt_0 =
"%6.2f\n";
-
+
char *cpu_fmt_1 =
"%5d %5d %-7.2f %7d %6d %7.1f %-6.2f %-6.3f\n\
%5d %-7.2f %7d %7.1f %-6.2f %-6.3f\n\n";
-
+
int messages_recvd;
- float elapsed_time,
- local_cpu_utilization,
+ float elapsed_time,
+ local_cpu_utilization,
remote_cpu_utilization;
-
+
float local_service_demand, remote_service_demand;
double local_thruput, remote_thruput;
double bytes_sent;
double bytes_recvd;
-
-
+
+
int len;
struct ring_elt *send_ring;
int failed_sends;
int failed_cows;
int messages_sent;
SOCKET data_socket;
-
-
+
+
#ifdef WANT_INTERVALS
int interval_count;
#endif /* WANT_INTERVALS */
@@ -1574,27 +1571,27 @@
int *message_int_ptr;
int i;
#endif /* DIRTY */
-
+
struct sockaddr_un server;
-
+
struct dg_stream_request_struct *dg_stream_request;
struct dg_stream_response_struct *dg_stream_response;
struct dg_stream_results_struct *dg_stream_results;
-
+
dg_stream_request = (struct dg_stream_request_struct *)netperf_request.content.test_specific_data;
dg_stream_response = (struct dg_stream_response_struct *)netperf_response.content.test_specific_data;
dg_stream_results = (struct dg_stream_results_struct *)netperf_response.content.test_specific_data;
-
- /* 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. */
-
+
+ /* 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. */
+
bzero((char *)&server,
sizeof(server));
-
+
server.sun_family = AF_UNIX;
-
+
if ( print_headers ) {
printf("DG UNIDIRECTIONAL SEND TEST\n");
if (local_cpu_usage || remote_cpu_usage)
@@ -1602,21 +1599,21 @@
else
printf(tput_title,format_units());
}
-
+
failed_sends = 0;
failed_cows = 0;
messages_sent = 0;
times_up = 0;
-
+
/*set up the data socket */
data_socket = create_unix_socket(AF_UNIX,
SOCK_DGRAM);
-
+
if (data_socket == INVALID_SOCKET){
perror("dg_send: data socket");
exit(1);
}
-
+
/* now, we want to see if we need to set the send_size */
if (send_size == 0) {
if (lss_size > 0) {
@@ -1626,13 +1623,13 @@
send_size = 4096;
}
}
-
-
- /* set-up the data buffer with the requested alignment and offset, */
- /* most of the numbers here are just a hack to pick something nice */
- /* and big in an attempt to never try to send a buffer a second time */
- /* before it leaves the node...unless the user set the width */
- /* explicitly. */
+
+
+ /* set-up the data buffer with the requested alignment and offset,
+ most of the numbers here are just a hack to pick something nice
+ and big in an attempt to never try to send a buffer a second time
+ before it leaves the node...unless the user set the width
+ explicitly. */
if (send_width == 0) send_width = 32;
send_ring = allocate_buffer_ring(send_width,
@@ -1640,24 +1637,25 @@
local_send_align,
local_send_offset);
- /* At this point, we want to do things like disable DG checksumming */
- /* and measure the cpu rate and all that so we are ready to go */
- /* immediately after the test response message is delivered. */
-
- /* if the user supplied a cpu rate, this call will complete rather */
- /* quickly, otherwise, the cpu rate will be retured to us for */
- /* possible display. The Library will keep it's own copy of this data */
- /* for use elsewhere. We will only display it. (Does that make it */
- /* "opaque" to us?) */
-
+ /* At this point, we want to do things like disable DG checksumming
+ and measure the cpu rate and all that so we are ready to go
+ immediately after the test response message is delivered. */
+
+ /* if the user supplied a cpu rate, this call will complete rather
+ quickly, otherwise, the cpu rate will be retured to us for
+ possible display. The Library will keep it's own copy of this
+ data for use elsewhere. We will only display it. (Does that make
+ it "opaque" to us?) */
+
if (local_cpu_usage)
local_cpu_rate = calibrate_local_cpu(local_cpu_rate);
-
- /* Tell the remote end to set up the data connection. The server */
- /* sends back the port number and alters the socket parameters there. */
- /* Of course this is a datagram service so no connection is actually */
- /* set up, the server just sets up the socket and binds it. */
-
+
+ /* Tell the remote end to set up the data connection. The server
+ sends back the port number and alters the socket parameters
+ there. Of course this is a datagram service so no connection is
+ actually set up, the server just sets up the socket and binds
+ it. */
+
netperf_request.content.request_type = DO_DG_STREAM;
dg_stream_request->recv_buf_size = rsr_size;
dg_stream_request->message_size = send_size;
@@ -1666,11 +1664,11 @@
dg_stream_request->measure_cpu = remote_cpu_usage;
dg_stream_request->cpu_rate = remote_cpu_rate;
dg_stream_request->test_length = test_time;
-
+
send_request();
-
+
recv_response();
-
+
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"send_dg_stream: remote data connection done.\n");
@@ -1680,54 +1678,56 @@
perror("send_dg_stream: error on remote");
exit(1);
}
-
- /* Place the port number returned by the remote into the sockaddr */
- /* structure so our sends can be sent to the correct place. Also get */
- /* some of the returned socket buffer information for user display. */
-
+
+ /* Place the port number returned by the remote into the sockaddr
+ structure so our sends can be sent to the correct place. Also get
+ some of the returned socket buffer information for user
+ display. */
+
/* make sure that port numbers are in the proper order */
strcpy(server.sun_path,dg_stream_response->unix_path);
rsr_size = dg_stream_response->recv_buf_size;
rss_size = dg_stream_response->send_buf_size;
remote_cpu_rate = dg_stream_response->cpu_rate;
-
- /* We "connect" up to the remote post to allow is to use the send */
- /* call instead of the sendto call. Presumeably, this is a little */
- /* simpler, and a little more efficient. I think that it also means */
- /* that we can be informed of certain things, but am not sure yet... */
-
+
+ /* We "connect" up to the remote post to allow is to use the send
+ call instead of the sendto call. Presumeably, this is a little
+ simpler, and a little more efficient. I think that it also means
+ that we can be informed of certain things, but am not sure
+ yet... */
+
if (connect(data_socket,
(struct sockaddr *)&server,
sizeof(server)) == INVALID_SOCKET){
perror("send_dg_stream: data socket connect failed");
exit(1);
}
-
- /* set up the timer to call us after test_time */
+
+ /* set up the timer to call us after test_time */
start_timer(test_time);
-
+
/* Get the start count for the idle counter and the start time */
-
+
cpu_start(local_cpu_usage);
-
+
#ifdef WANT_INTERVALS
interval_count = interval_burst;
#endif
-
- /* Send datagrams like there was no tomorrow. at somepoint it might */
- /* be nice to set this up so that a quantity of bytes could be sent, */
- /* but we still need some sort of end of test trigger on the receive */
- /* side. that could be a select with a one second timeout, but then */
- /* if there is a test where none of the data arrives for awile and */
- /* then starts again, we would end the test too soon. something to */
- /* think about... */
+
+ /* Send datagrams like there was no tomorrow. at somepoint it might
+ be nice to set this up so that a quantity of bytes could be sent,
+ but we still need some sort of end of test trigger on the receive
+ side. that could be a select with a one second timeout, but then
+ if there is a test where none of the data arrives for awile and
+ then starts again, we would end the test too soon. something to
+ think about... */
while (!times_up) {
#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. */
+ /* 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. */
message_int_ptr = (int *)(send_ring->buffer_ptr);
for (i = 0; i < loc_dirty_count; i++) {
*message_int_ptr = 4;
@@ -1752,41 +1752,41 @@
perror("dg_send: data send error");
exit(1);
}
- messages_sent++;
-
- /* now we want to move our pointer to the next position in the */
- /* data buffer... */
+ messages_sent++;
+ /* now we want to move our pointer to the next position in the
+ data buffer... */
+
send_ring = send_ring->next;
-
-
+
+
#ifdef WANT_INTERVALS
- /* in this case, the interval count is the count-down couter */
- /* to decide to sleep for a little bit */
+ /* 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 the sleep routine for some milliseconds, if our */
- /* timer popped while we were in there, we want to */
- /* break out of the loop. */
+ /* call the sleep routine for some milliseconds, if our timer
+ popped while we were in there, we want to break out of the
+ loop. */
if (msec_sleep(interval_wate)) {
break;
}
interval_count = interval_burst;
}
-
+
#endif
-
+
}
-
- /* This is a timed test, so the remote will be returning to us after */
- /* a time. We should not need to send any "strange" messages to tell */
- /* the remote that the test is completed, unless we decide to add a */
- /* number of messages to the test. */
-
+
+ /* This is a timed test, so the remote will be returning to us after
+ a time. We should not need to send any "strange" messages to tell
+ the remote that the test is completed, unless we decide to add a
+ number of messages to the test. */
+
/* the test is over, so get stats and stuff */
cpu_stop(local_cpu_usage,
&elapsed_time);
-
- /* Get the statistics from the remote end */
+
+ /* Get the statistics from the remote end */
recv_response();
if (!netperf_response.content.serv_errno) {
if (debug)
@@ -1797,31 +1797,31 @@
perror("send_dg_stream: error on remote");
exit(1);
}
-
+
bytes_sent = send_size * messages_sent;
local_thruput = calc_thruput(bytes_sent);
-
+
messages_recvd = dg_stream_results->messages_recvd;
bytes_recvd = send_size * messages_recvd;
-
+
/* we asume that the remote ran for as long as we did */
-
+
remote_thruput = calc_thruput(bytes_recvd);
-
+
/* print the results for this socket and message size */
-
+
if (local_cpu_usage || remote_cpu_usage) {
- /* We must now do a little math for service demand and cpu */
- /* utilization for the system(s) We pass zeros for the local */
- /* cpu utilization and elapsed time to tell the routine to use */
- /* the libraries own values for those. */
+ /* We must now do a little math for service demand and cpu
+ utilization for the system(s) We pass zeros for the local cpu
+ utilization and elapsed time to tell the routine to use the
+ libraries own values for those. */
if (local_cpu_usage) {
if (local_cpu_rate == 0.0) {
fprintf(where,"WARNING WARNING WARNING WARNING WARNING WARNING WARNING!\n");
fprintf(where,"Local CPU usage numbers based on process information only!\n");
fflush(where);
}
-
+
local_cpu_utilization = calc_cpu_util(0.0);
local_service_demand = calc_service_demand(bytes_sent,
0.0,
@@ -1832,17 +1832,17 @@
local_cpu_utilization = -1.0;
local_service_demand = -1.0;
}
-
- /* The local calculations could use variables being kept by */
- /* the local netlib routines. The remote calcuations need to */
- /* have a few things passed to them. */
+
+ /* The local calculations could use variables being kept by the
+ local netlib routines. The remote calcuations need to have a
+ few things passed to them. */
if (remote_cpu_usage) {
if (remote_cpu_rate == 0.0) {
fprintf(where,"DANGER DANGER DANGER DANGER DANGER DANGER DANGER!\n");
fprintf(where,"REMOTE CPU usage numbers based on process information only!\n");
fflush(where);
}
-
+
remote_cpu_utilization = dg_stream_results->cpu_util;
remote_service_demand = calc_service_demand(bytes_recvd,
0.0,
@@ -1853,16 +1853,16 @@
remote_cpu_utilization = -1.0;
remote_service_demand = -1.0;
}
-
- /* 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... */
-
+
+ /* 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... */
+
switch (verbosity) {
case 0:
if (local_cpu_usage) {
@@ -1878,15 +1878,15 @@
break;
case 1:
fprintf(where,
- cpu_fmt_1, /* the format string */
- lss_size, /* local sendbuf size */
- send_size, /* how large were the sends */
- elapsed_time, /* how long was the test */
+ cpu_fmt_1, /* the format string */
+ lss_size, /* local sendbuf size */
+ send_size, /* how large were the sends */
+ elapsed_time, /* how long was the test */
messages_sent,
failed_sends,
- local_thruput, /* what was the xfer rate */
- local_cpu_utilization, /* local cpu */
- local_service_demand, /* local service demand */
+ local_thruput, /* what was the xfer rate */
+ local_cpu_utilization,/* local cpu */
+ local_service_demand, /* local service demand */
rsr_size,
elapsed_time,
messages_recvd,
@@ -1924,8 +1924,8 @@
}
- /* this routine implements the receive side (netserver) of the */
- /* DG_STREAM performance test. */
+ /* this routine implements the receive side (netserver) of the
+ DG_STREAM performance test. */
void
recv_dg_stream()
@@ -1937,54 +1937,54 @@
int len = 0;
int bytes_received = 0;
float elapsed_time;
-
+
int message_size;
int messages_recvd = 0;
-
+
struct dg_stream_request_struct *dg_stream_request;
struct dg_stream_response_struct *dg_stream_response;
struct dg_stream_results_struct *dg_stream_results;
-
- dg_stream_request =
+
+ dg_stream_request =
(struct dg_stream_request_struct *)netperf_request.content.test_specific_data;
- dg_stream_response =
+ dg_stream_response =
(struct dg_stream_response_struct *)netperf_response.content.test_specific_data;
- dg_stream_results =
+ dg_stream_results =
(struct dg_stream_results_struct *)netperf_response.content.test_specific_data;
-
+
if (debug) {
fprintf(where,"netserver: recv_dg_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. */
-
+
+ /* 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 > 1) {
fprintf(where,"recv_dg_stream: setting the response type...\n");
fflush(where);
}
-
+
netperf_response.content.response_type = DG_STREAM_RESPONSE;
-
+
if (debug > 2) {
fprintf(where,"recv_dg_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. */
-
+
+ /* We now alter the message_ptr variable to be at the desired
+ alignment with the desired offset. */
+
if (debug > 1) {
fprintf(where,"recv_dg_stream: requested alignment of %d\n",
dg_stream_request->recv_alignment);
@@ -2002,44 +2002,44 @@
fprintf(where,"recv_dg_stream: receive alignment and offset set...\n");
fflush(where);
}
-
- /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
- /* can put in OUR values !-) At some point, we may want to nail this */
- /* socket to a particular network-level address, but for now, */
- /* INADDR_ANY should be just fine. */
-
+
+ /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
+ can put in OUR values !-) At some point, we may want to nail this
+ socket to a particular network-level address, but for now,
+ INADDR_ANY should be just fine. */
+
bzero((char *)&myaddr_un,
sizeof(myaddr_un));
myaddr_un.sun_family = AF_UNIX;
-
+
/* Grab a socket to listen on, and then listen on it. */
-
+
if (debug > 1) {
fprintf(where,"recv_dg_stream: grabbing a socket...\n");
fflush(where);
}
- /* create_unix_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 */
+ /* create_unix_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 */
lsr_size = dg_stream_request->recv_buf_size;
-
+
s_data = create_unix_socket(AF_UNIX,
SOCK_DGRAM);
-
+
if (s_data == INVALID_SOCKET) {
netperf_response.content.serv_errno = errno;
send_response();
exit(1);
}
-
- /* Let's get an address assigned to this socket so we can tell the */
- /* initiator how to reach the data socket. There may be a desire to */
- /* nail this socket to a specific IP address in a multi-homed, */
- /* multi-connection situation, but for now, we'll ignore the issue */
- /* and concentrate on single connection testing. */
-
+
+ /* Let's get an address assigned to this socket so we can tell the
+ initiator how to reach the data socket. There may be a desire to
+ nail this socket to a specific IP address in a multi-homed,
+ multi-connection situation, but for now, we'll ignore the issue
+ and concentrate on single connection testing. */
+
strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
if (bind(s_data,
(struct sockaddr *)&myaddr_un,
@@ -2052,61 +2052,61 @@
chmod(myaddr_un.sun_path, 0666);
dg_stream_response->test_length = dg_stream_request->test_length;
-
- /* Now myaddr_un 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. */
-
+
+ /* Now myaddr_un 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. */
+
strcpy(dg_stream_response->unix_path,myaddr_un.sun_path);
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. */
-
+
+ /* 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. */
+
dg_stream_response->cpu_rate = 0.0; /* assume no cpu */
if (dg_stream_request->measure_cpu) {
- /* We will pass the rate into the calibration routine. If the */
- /* user did not specify one, it will be 0.0, and we will do a */
- /* "real" calibration. Otherwise, all it will really do is */
- /* store it away... */
+ /* We will pass the rate into the calibration routine. If the user
+ did not specify one, it will be 0.0, and we will do a "real"
+ calibration. Otherwise, all it will really do is store it
+ away... */
dg_stream_response->measure_cpu = 1;
- dg_stream_response->cpu_rate =
+ dg_stream_response->cpu_rate =
calibrate_local_cpu(dg_stream_request->cpu_rate);
}
-
+
message_size = dg_stream_request->message_size;
test_time = dg_stream_request->test_length;
-
- /* before we send the response back to the initiator, pull some of */
- /* the socket parms from the globals */
+
+ /* before we send the response back to the initiator, pull some of
+ the socket parms from the globals */
dg_stream_response->send_buf_size = lss_size;
dg_stream_response->recv_buf_size = lsr_size;
send_response();
-
- /* Now it's time to start receiving data on the connection. We will */
- /* first grab the apropriate counters and then start grabbing. */
-
+
+ /* Now it's time to start receiving data on the connection. We will
+ first grab the apropriate counters and then start grabbing. */
+
cpu_start(dg_stream_request->measure_cpu);
-
- /* The loop will exit when the timer pops, or if we happen to recv a */
- /* message of less than send_size bytes... */
-
+
+ /* The loop will exit when the timer pops, or if we happen to recv a
+ message of less than send_size bytes... */
+
times_up = 0;
start_timer(test_time + PAD_TIME);
-
+
if (debug) {
fprintf(where,"recv_dg_stream: about to enter inner sanctum.\n");
fflush(where);
}
-
+
while (!times_up) {
- if ((len = recv(s_data,
+ if ((len = recv(s_data,
recv_ring->buffer_ptr,
- message_size,
+ message_size,
0)) != message_size) {
if ((len == SOCKET_ERROR) && (errno != EINTR)) {
netperf_response.content.serv_errno = errno;
@@ -2118,17 +2118,17 @@
messages_recvd++;
recv_ring = recv_ring->next;
}
-
+
if (debug) {
fprintf(where,"recv_dg_stream: got %d messages.\n",messages_recvd);
fflush(where);
}
-
-
+
+
/* The loop now exits due timer or < send_size bytes received. */
-
+
cpu_stop(dg_stream_request->measure_cpu,&elapsed_time);
-
+
if (times_up) {
/* we ended on a timer, subtract the PAD_TIME */
elapsed_time -= (float)PAD_TIME;
@@ -2136,25 +2136,25 @@
else {
stop_timer();
}
-
+
if (debug) {
fprintf(where,"recv_dg_stream: test ended in %f seconds.\n",elapsed_time);
fflush(where);
}
-
-
+
+
/* We will count the "off" message that got us out of the loop */
bytes_received = (messages_recvd * message_size) + len;
-
+
/* send the results to the sender */
-
+
if (debug) {
fprintf(where,
"recv_dg_stream: got %d bytes\n",
bytes_received);
fflush(where);
}
-
+
netperf_response.content.response_type = DG_STREAM_RESULTS;
dg_stream_results->bytes_received = bytes_received;
dg_stream_results->messages_recvd = messages_recvd;
@@ -2165,57 +2165,57 @@
else {
dg_stream_results->cpu_util = -1.0;
}
-
+
if (debug > 1) {
fprintf(where,
"recv_dg_stream: test complete, sending results.\n");
fflush(where);
}
-
+
send_response();
-
+
}
void
send_dg_rr(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 %% %% us/Tr us/Tr\n\n";
-
+
char *cpu_fmt_0 =
"%6.3f\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";
-
+
float elapsed_time;
-
- /* we add MAXALIGNMENT and MAXOFFSET to insure that there is enough */
- /* space for a maximally aligned, maximally sized message. At some */
- /* point, we may want to actually make this even larger and cycle */
- /* through the thing one piece at a time.*/
-
+
+ /* we add MAXALIGNMENT and MAXOFFSET to insure that there is enough
+ space for a maximally aligned, maximally sized message. At some
+ point, we may want to actually make this even larger and cycle
+ through the thing one piece at a time.*/
+
int len;
char *send_message_ptr;
char *recv_message_ptr;
@@ -2224,15 +2224,15 @@
SOCKET send_socket;
int trans_remaining;
int bytes_xferd;
-
+
int rsp_bytes_recvd;
-
+
float local_cpu_utilization;
float local_service_demand;
float remote_cpu_utilization;
float remote_service_demand;
double thruput;
-
+
#ifdef WANT_INTERVALS
/* timing stuff */
#define MAX_KEPT_TIMES 1024
@@ -2246,20 +2246,20 @@
struct timeval recv_time;
struct timeval sleep_timeval;
#endif
-
+
struct sockaddr_un server, myaddr_un;
-
+
struct dg_rr_request_struct *dg_rr_request;
struct dg_rr_response_struct *dg_rr_response;
struct dg_rr_results_struct *dg_rr_result;
-
- dg_rr_request =
+
+ dg_rr_request =
(struct dg_rr_request_struct *)netperf_request.content.test_specific_data;
dg_rr_response=
(struct dg_rr_response_struct *)netperf_response.content.test_specific_data;
dg_rr_result =
(struct dg_rr_results_struct *)netperf_response.content.test_specific_data;
-
+
/* we want to zero out the times, so we can detect unused entries. */
#ifdef WANT_INTERVALS
time_index = 0;
@@ -2269,12 +2269,12 @@
}
time_index = 0;
#endif
-
- /* 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. */
-
+
+ /* 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. */
+
bzero((char *)&server,
sizeof(server));
server.sun_family = AF_UNIX;
@@ -2284,7 +2284,7 @@
myaddr_un.sun_family = AF_UNIX;
strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
-
+
if ( print_headers ) {
fprintf(where,"DG REQUEST/RESPONSE TEST\n");
if (local_cpu_usage || remote_cpu_usage)
@@ -2292,20 +2292,20 @@
else
fprintf(where,tput_title,format_units());
}
-
+
/* initialize a few counters */
-
+
nummessages = 0;
bytes_xferd = 0;
times_up = 0;
-
+
/* set-up the data buffer with the requested alignment and offset */
temp_message_ptr = (char *)malloc(DATABUFFERLEN);
if (temp_message_ptr == NULL) {
printf("malloc(%d) failed!\n", DATABUFFERLEN);
exit(1);
}
- send_message_ptr = (char *)(( (long)temp_message_ptr +
+ send_message_ptr = (char *)(( (long)temp_message_ptr +
(long) local_send_align - 1) &
~((long) local_send_align - 1));
send_message_ptr = send_message_ptr + local_send_offset;
@@ -2314,46 +2314,46 @@
printf("malloc(%d) failed!\n", DATABUFFERLEN);
exit(1);
}
- recv_message_ptr = (char *)(( (long)temp_message_ptr +
+ recv_message_ptr = (char *)(( (long)temp_message_ptr +
(long) local_recv_align - 1) &
~((long) local_recv_align - 1));
recv_message_ptr = recv_message_ptr + local_recv_offset;
-
+
/*set up the data socket */
- send_socket = create_unix_socket(AF_UNIX,
+ send_socket = create_unix_socket(AF_UNIX,
SOCK_DGRAM);
-
+
if (send_socket == INVALID_SOCKET){
perror("netperf: send_dg_rr: dg rr data socket");
exit(1);
}
-
+
if (debug) {
fprintf(where,"send_dg_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 */
- /* there is no idle counter in the kernel idle loop, the */
- /* local_cpu_rate will be set to -1. */
-
+ /* 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
+ there is no idle counter in the kernel idle loop, the
+ local_cpu_rate will be set to -1. */
+
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. */
-
+
+ /* 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_DG_RR;
dg_rr_request->recv_buf_size = rsr_size;
dg_rr_request->send_buf_size = rss_size;
@@ -2371,25 +2371,25 @@
else {
dg_rr_request->test_length = test_trans * -1;
}
-
+
if (debug > 1) {
fprintf(where,"netperf: send_dg_rr: requesting DG request/response 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 DG tests. */
-
+
+ /* 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 DG tests. */
+
recv_response();
-
+
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote listen done.\n");
@@ -2403,13 +2403,13 @@
else {
Set_errno(netperf_response.content.serv_errno);
perror("netperf: remote error");
-
+
exit(1);
}
-
- /* Connect up to the remote port on the data socket. This will set */
- /* the default destination address on this socket. we need to bind */
- /* out socket so that the remote gets something from a recvfrom */
+
+ /* Connect up to the remote port on the data socket. This will set
+ the default destination address on this socket. we need to bind
+ out socket so that the remote gets something from a recvfrom */
if (bind(send_socket,
(struct sockaddr *)&myaddr_un,
sizeof(myaddr_un)) == SOCKET_ERROR) {
@@ -2418,23 +2418,23 @@
close(send_socket);
exit(1);
}
-
- if (connect(send_socket,
+
+ if (connect(send_socket,
(struct sockaddr *)&server,
sizeof(server)) == INVALID_SOCKET ) {
perror("netperf: data socket connect failed");
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. */
-
+
+ /* 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;
@@ -2446,21 +2446,22 @@
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. */
-
+
+ /* 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);
-
- /* 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. */
+
+ /* 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. */
while ((!times_up) || (trans_remaining > 0)) {
/* send the request */
#ifdef WANT_INTERVALS
@@ -2478,9 +2479,9 @@
perror("send_dg_rr: data send error");
exit(1);
}
-
+
/* receive the response. with DG we will get it all, or nothing */
-
+
if((rsp_bytes_recvd=recv(send_socket,
recv_message_ptr,
rsp_size,
@@ -2494,23 +2495,22 @@
}
#ifdef WANT_INTERVALS
gettimeofday(&recv_time,&dummy_zone);
-
+
/* now we do some arithmatic on the two timevals */
if (recv_time.tv_usec < send_time.tv_usec) {
/* we wrapped around a second */
recv_time.tv_usec += 1000000;
recv_time.tv_sec -= 1;
}
-
+
/* and store it away */
kept_times[time_index] = (recv_time.tv_sec - send_time.tv_sec) * 1000000;
kept_times[time_index] += (recv_time.tv_usec - send_time.tv_usec);
-
- /* at this point, we may wish to sleep for some period of */
- /* time, so we see how long that last transaction just took, */
- /* and sleep for the difference of that and the interval. We */
- /* will not sleep if the time would be less than a */
- /* millisecond. */
+
+ /* at this point, we may wish to sleep for some period of time, so
+ we see how long that last transaction just took, and sleep for
+ the difference of that and the interval. We will not sleep if
+ the time would be less than a millisecond. */
if (interval_usecs > 0) {
sleep_usecs = interval_usecs - kept_times[time_index];
if (sleep_usecs > 1000) {
@@ -2524,43 +2524,45 @@
&sleep_timeval);
}
}
-
+
/* now up the time index */
time_index = (time_index +1)%MAX_KEPT_TIMES;
#endif
- nummessages++;
+ nummessages++;
if (trans_remaining) {
trans_remaining--;
}
-
+
if (debug > 3) {
fprintf(where,"Transaction %d completed\n",nummessages);
fflush(where);
}
-
+
}
-
- /* 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. Of course, since this was a request/response test, there */
- /* should be no data outstanding on the socket ;-) */
-
+
+ /* 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. Of course, since this was a request/response test, there
+ should be no data outstanding on the socket ;-) */
+
if (shutdown(send_socket,1) == SOCKET_ERROR) {
perror("netperf: cannot shutdown dg stream socket");
-
+
exit(1);
}
-
- /* 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 service demand and all those interesting things. If it */
- /* wasn't supposed to care, it will return obvious values. */
-
+
+ /* 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 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)
@@ -2569,28 +2571,29 @@
else {
Set_errno(netperf_response.content.serv_errno);
perror("netperf: remote error");
-
+
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 DG 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 ;-) We use */
-
+
+ /* 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 DG
+ 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 ;-) We use */
+
bytes_xferd = (req_size * nummessages) + (rsp_size * nummessages);
thruput = calc_thruput(bytes_xferd);
-
+
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...*/
+ /* 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) {
if (local_cpu_rate == 0.0) {
fprintf(where,"WARNING WARNING WARNING WARNING WARNING WARNING WARNING!\n");
@@ -2598,9 +2601,8 @@
fflush(where);
}
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 */
+ /* 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,
@@ -2610,7 +2612,7 @@
local_cpu_utilization = -1.0;
local_service_demand = -1.0;
}
-
+
if (remote_cpu_usage) {
if (remote_cpu_rate == 0.0) {
fprintf(where,"DANGER DANGER DANGER DANGER DANGER DANGER DANGER!\n");
@@ -2618,9 +2620,8 @@
fflush(where);
}
remote_cpu_utilization = dg_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 */
+ /* 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,
@@ -2630,16 +2631,16 @@
remote_cpu_utilization = -1.0;
remote_service_demand = -1.0;
}
-
- /* 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... */
-
+
+ /* 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... */
+
switch (verbosity) {
case 0:
if (local_cpu_usage) {
@@ -2656,12 +2657,12 @@
case 1:
case 2:
fprintf(where,
- cpu_fmt_1_line_1, /* the format string */
+ 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 */
+ elapsed_time, /* how long was the test */
nummessages/elapsed_time,
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
@@ -2696,23 +2697,23 @@
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. */
-
+
+ /* 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 */
- /* DG statistics, the alignments of the sends and receives */
- /* and all that sort of rot... */
-
+ /* 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 DG
+ statistics, the alignments of the sends and receives and all
+ that sort of rot... */
+
#ifdef WANT_INTERVALS
kept_times[MAX_KEPT_TIMES] = 0;
time_index = 0;
@@ -2733,12 +2734,12 @@
unlink(myaddr_un.sun_path);
}
- /* this routine implements the receive side (netserver) of a DG_RR */
- /* test. */
+ /* this routine implements the receive side (netserver) of a DG_RR
+ test. */
void
recv_dg_rr()
{
-
+
struct ring_elt *recv_ring;
struct ring_elt *send_ring;
@@ -2749,51 +2750,51 @@
int trans_received = 0;
int trans_remaining;
float elapsed_time;
-
+
struct dg_rr_request_struct *dg_rr_request;
struct dg_rr_response_struct *dg_rr_response;
struct dg_rr_results_struct *dg_rr_results;
-
- dg_rr_request =
+
+ dg_rr_request =
(struct dg_rr_request_struct *)netperf_request.content.test_specific_data;
- dg_rr_response =
+ dg_rr_response =
(struct dg_rr_response_struct *)netperf_response.content.test_specific_data;
- dg_rr_results =
+ dg_rr_results =
(struct dg_rr_results_struct *)netperf_response.content.test_specific_data;
-
+
if (debug) {
fprintf(where,"netserver: recv_dg_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. */
-
+
+ /* 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_dg_rr: setting the response type...\n");
fflush(where);
}
-
+
netperf_response.content.response_type = DG_RR_RESPONSE;
-
+
if (debug) {
fprintf(where,"recv_dg_rr: the response type is set...\n");
fflush(where);
}
-
- /* We now alter the message_ptr variables to be at the desired */
- /* alignments with the desired offsets. */
-
+
+ /* We now alter the message_ptr variables to be at the desired
+ alignments with the desired offsets. */
+
if (debug) {
fprintf(where,"recv_dg_rr: requested recv alignment of %d offset %d\n",
dg_rr_request->recv_alignment,
@@ -2821,47 +2822,47 @@
fprintf(where,"recv_dg_rr: receive alignment and offset set...\n");
fflush(where);
}
-
- /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
- /* can put in OUR values !-) At some point, we may want to nail this */
- /* socket to a particular network-level address, but for now, */
- /* INADDR_ANY should be just fine. */
-
+
+ /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
+ can put in OUR values !-) At some point, we may want to nail this
+ socket to a particular network-level address, but for now,
+ INADDR_ANY should be just fine. */
+
bzero((char *)&myaddr_un,
sizeof(myaddr_un));
myaddr_un.sun_family = AF_UNIX;
-
+
/* Grab a socket to listen on, and then listen on it. */
-
+
if (debug) {
fprintf(where,"recv_dg_rr: grabbing a socket...\n");
fflush(where);
}
-
- /* create_unix_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 */
+
+ /* create_unix_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 = dg_rr_request->send_buf_size;
lsr_size_req = dg_rr_request->recv_buf_size;
s_data = create_unix_socket(AF_UNIX,
SOCK_DGRAM);
-
+
if (s_data == INVALID_SOCKET) {
netperf_response.content.serv_errno = errno;
send_response();
-
+
exit(1);
}
-
- /* Let's get an address assigned to this socket so we can tell the */
- /* initiator how to reach the data socket. There may be a desire to */
- /* nail this socket to a specific IP address in a multi-homed, */
- /* multi-connection situation, but for now, we'll ignore the issue */
- /* and concentrate on single connection testing. */
-
+
+ /* Let's get an address assigned to this socket so we can tell the
+ initiator how to reach the data socket. There may be a desire to
+ nail this socket to a specific IP address in a multi-homed,
+ multi-connection situation, but for now, we'll ignore the issue
+ and concentrate on single connection testing. */
+
strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
if (bind(s_data,
(struct sockaddr *)&myaddr_un,
@@ -2870,42 +2871,42 @@
unlink(myaddr_un.sun_path);
close(s_data);
send_response();
-
+
exit(1);
}
-
- /* Now myaddr_un 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. */
-
+
+ /* Now myaddr_un 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. */
+
strcpy(dg_rr_response->unix_path,myaddr_un.sun_path);
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. */
-
+
+ /* 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. */
+
dg_rr_response->cpu_rate = 0.0; /* assume no cpu */
if (dg_rr_request->measure_cpu) {
dg_rr_response->measure_cpu = 1;
dg_rr_response->cpu_rate = calibrate_local_cpu(dg_rr_request->cpu_rate);
}
-
- /* before we send the response back to the initiator, pull some of */
- /* the socket parms from the globals */
+
+ /* before we send the response back to the initiator, pull some of
+ the socket parms from the globals */
dg_rr_response->send_buf_size = lss_size;
dg_rr_response->recv_buf_size = lsr_size;
-
+
send_response();
-
-
- /* Now it's time to start receiving data on the connection. We will */
- /* first grab the apropriate counters and then start grabbing. */
-
+
+
+ /* Now it's time to start receiving data on the connection. We will
+ first grab the apropriate counters and then start grabbing. */
+
cpu_start(dg_rr_request->measure_cpu);
-
+
if (dg_rr_request->test_length > 0) {
times_up = 0;
trans_remaining = 0;
@@ -2915,12 +2916,12 @@
times_up = 1;
trans_remaining = dg_rr_request->test_length * -1;
}
-
+
addrlen = sizeof(peeraddr_un);
bzero((char *)&peeraddr_un, addrlen);
-
+
while ((!times_up) || (trans_remaining > 0)) {
-
+
/* receive the request from the other side */
fprintf(where,"socket %d ptr %p size %d\n",
s_data,
@@ -2965,68 +2966,68 @@
exit(1);
}
send_ring = send_ring->next;
-
+
trans_received++;
if (trans_remaining) {
trans_remaining--;
}
-
+
if (debug) {
fprintf(where,
"recv_dg_rr: Transaction %d complete.\n",
trans_received);
fflush(where);
}
-
+
}
-
-
- /* The loop now exits due to timeout or transaction count being */
- /* reached */
-
+
+
+ /* The loop now exits due to timeout or transaction count being
+ reached */
+
cpu_stop(dg_rr_request->measure_cpu,&elapsed_time);
-
+
if (times_up) {
- /* 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. */
+ /* 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_dg_rr: got %d transactions\n",
trans_received);
fflush(where);
}
-
- dg_rr_results->bytes_received = (trans_received *
- (dg_rr_request->request_size +
+
+ dg_rr_results->bytes_received = (trans_received *
+ (dg_rr_request->request_size +
dg_rr_request->response_size));
dg_rr_results->trans_received = trans_received;
dg_rr_results->elapsed_time = elapsed_time;
if (dg_rr_request->measure_cpu) {
dg_rr_results->cpu_util = calc_cpu_util(elapsed_time);
}
-
+
if (debug) {
fprintf(where,
"recv_dg_rr: test complete, sending results.\n");
fflush(where);
}
-
+
send_response();
unlink(myaddr_un.sun_path);
-
+
}
- /* this routine implements the receive (netserver) side of a STREAM_RR */
- /* test */
+ /* this routine implements the receive (netserver) side of a
+ STREAM_RR test */
void
recv_stream_rr()
{
-
+
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
@@ -3042,50 +3043,50 @@
int request_bytes_remaining;
int timed_out = 0;
float elapsed_time;
-
+
struct stream_rr_request_struct *stream_rr_request;
struct stream_rr_response_struct *stream_rr_response;
struct stream_rr_results_struct *stream_rr_results;
-
- stream_rr_request =
+
+ stream_rr_request =
(struct stream_rr_request_struct *)netperf_request.content.test_specific_data;
stream_rr_response =
(struct stream_rr_response_struct *)netperf_response.content.test_specific_data;
stream_rr_results =
(struct stream_rr_results_struct *)netperf_response.content.test_specific_data;
-
+
if (debug) {
fprintf(where,"netserver: recv_stream_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. */
-
+
+ /* 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_stream_rr: setting the response type...\n");
fflush(where);
}
-
+
netperf_response.content.response_type = STREAM_RR_RESPONSE;
-
+
if (debug) {
fprintf(where,"recv_stream_rr: the response type is set...\n");
fflush(where);
}
-
- /* allocate the recv and send rings with the requested alignments */
- /* and offsets. raj 7/94 */
+
+ /* allocate the recv and send rings with the requested alignments
+ and offsets. raj 7/94 */
if (debug) {
fprintf(where,"recv_stream_rr: requested recv alignment of %d offset %d\n",
stream_rr_request->recv_alignment,
@@ -3110,46 +3111,46 @@
stream_rr_request->recv_alignment,
stream_rr_request->recv_offset);
-
- /* Let's clear-out our sockaddr for the sake of cleanlines. Then we */
- /* can put in OUR values !-) At some point, we may want to nail this */
- /* socket to a particular network-level address, but for now, */
- /* INADDR_ANY should be just fine. */
-
+
+ /* Let's clear-out our sockaddr for the sake of cleanlines. Then we
+ can put in OUR values !-) At some point, we may want to nail this
+ socket to a particular network-level address, but for now,
+ INADDR_ANY should be just fine. */
+
bzero((char *)&myaddr_un,
sizeof(myaddr_un));
myaddr_un.sun_family = AF_UNIX;
-
+
/* Grab a socket to listen on, and then listen on it. */
-
+
if (debug) {
fprintf(where,"recv_stream_rr: grabbing a socket...\n");
fflush(where);
}
- /* create_unix_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 */
+ /* create_unix_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 = stream_rr_request->send_buf_size;
lsr_size_req = stream_rr_request->recv_buf_size;
-
+
s_listen = create_unix_socket(AF_UNIX,
SOCK_STREAM);
-
+
if (s_listen == INVALID_SOCKET) {
netperf_response.content.serv_errno = errno;
send_response();
-
+
exit(1);
}
-
- /* Let's get an address assigned to this socket so we can tell the */
- /* initiator how to reach the data socket. There may be a desire to */
- /* nail this socket to a specific IP address in a multi-homed, */
- /* multi-connection situation, but for now, we'll ignore the issue */
- /* and concentrate on single connection testing. */
-
+
+ /* Let's get an address assigned to this socket so we can tell the
+ initiator how to reach the data socket. There may be a desire to
+ nail this socket to a specific IP address in a multi-homed,
+ multi-connection situation, but for now, we'll ignore the issue
+ and concentrate on single connection testing. */
+
strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf."));
if (bind(s_listen,
(struct sockaddr *)&myaddr_un,
@@ -3158,70 +3159,70 @@
unlink(myaddr_un.sun_path);
close(s_listen);
send_response();
-
+
exit(1);
}
-
+
/* Now, let's set-up the socket to listen for connections */
if (listen(s_listen, 5) == SOCKET_ERROR) {
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
-
+
exit(1);
}
-
- /* Now myaddr_un 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. */
-
+
+ /* Now myaddr_un 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. */
+
strcpy(stream_rr_response->unix_path,myaddr_un.sun_path);
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. */
-
+
+ /* 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. */
+
stream_rr_response->cpu_rate = 0.0; /* assume no cpu */
if (stream_rr_request->measure_cpu) {
stream_rr_response->measure_cpu = 1;
stream_rr_response->cpu_rate = calibrate_local_cpu(stream_rr_request->cpu_rate);
}
-
-
- /* before we send the response back to the initiator, pull some of */
- /* the socket parms from the globals */
+
+
+ /* before we send the response back to the initiator, pull some of
+ the socket parms from the globals */
stream_rr_response->send_buf_size = lss_size;
stream_rr_response->recv_buf_size = lsr_size;
send_response();
-
+
addrlen = sizeof(peeraddr_un);
-
+
if ((s_data = accept(s_listen,
(struct sockaddr *)&peeraddr_un,
&addrlen)) == INVALID_SOCKET) {
/* Let's just punt. The remote will be given some information */
close(s_listen);
-
+
exit(1);
}
-
+
if (debug) {
fprintf(where,"recv_stream_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. */
-
+
+ /* Now it's time to start receiving data on the connection. We will
+ first grab the apropriate counters and then start grabbing. */
+
cpu_start(stream_rr_request->measure_cpu);
-
- /* The loop will exit when the sender does a shutdown, which will */
- /* return a length of zero */
-
+
+ /* The loop will exit when the sender does a shutdown, which will
+ return a length of zero */
+
if (stream_rr_request->test_length > 0) {
times_up = 0;
trans_remaining = 0;
@@ -3231,11 +3232,11 @@
times_up = 1;
trans_remaining = stream_rr_request->test_length * -1;
}
-
+
while ((!times_up) || (trans_remaining > 0)) {
temp_message_ptr = recv_ring->buffer_ptr;
request_bytes_remaining = stream_rr_request->request_size;
-
+
/* receive the request from the other side */
if (debug) {
fprintf(where,"about to receive for trans %d\n",trans_received);
@@ -3269,13 +3270,13 @@
recv_ring = recv_ring->next;
if (timed_out) {
- /* we hit the end of the test based on time - lets */
- /* bail out of here now... */
+ /* we hit the end of the test based on time - lets
+ bail out of here now... */
fprintf(where,"yo5\n");
fflush(where);
break;
}
-
+
/* Now, send the response to the remote */
if (debug) {
fprintf(where,"about to send for trans %d\n",trans_received);
@@ -3296,14 +3297,14 @@
send_response();
exit(1);
}
-
+
send_ring = send_ring->next;
trans_received++;
if (trans_remaining) {
trans_remaining--;
}
-
+
if (debug) {
fprintf(where,
"recv_stream_rr: Transaction %d complete\n",
@@ -3311,43 +3312,43 @@
fflush(where);
}
}
-
-
- /* The loop now exits due to timeout or transaction count being */
- /* reached */
-
+
+
+ /* The loop now exits due to timeout or transaction count being
+ reached */
+
cpu_stop(stream_rr_request->measure_cpu,&elapsed_time);
-
+
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. */
+ /* 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_stream_rr: got %d transactions\n",
trans_received);
fflush(where);
}
-
- stream_rr_results->bytes_received = (trans_received *
- (stream_rr_request->request_size +
+
+ stream_rr_results->bytes_received = (trans_received *
+ (stream_rr_request->request_size +
stream_rr_request->response_size));
stream_rr_results->trans_received = trans_received;
stream_rr_results->elapsed_time = elapsed_time;
if (stream_rr_request->measure_cpu) {
stream_rr_results->cpu_util = calc_cpu_util(elapsed_time);
}
-
+
if (debug) {
fprintf(where,
"recv_stream_rr: test complete, sending results.\n");
fflush(where);
}
-
+
send_response();
unlink(myaddr_un.sun_path);
}
@@ -3365,13 +3366,13 @@
{
#define UNIX_ARGS "hm:M:p:r:s:S:"
extern char *optarg; /* pointer to option string */
-
+
int c;
-
+
char
arg1[BUFSIZ], /* argument holders */
arg2[BUFSIZ];
-
+
init_test_vars();
if (no_control) {
@@ -3380,12 +3381,12 @@
exit(-1);
}
- /* 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.. */
-
+ /* 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, UNIX_ARGS)) != EOF) {
switch (c) {
case '?':
@@ -3393,8 +3394,8 @@
print_unix_usage();
exit(1);
case 'p':
- /* set the path prefix (directory) that should be used for the */
- /* pipes. at some point, there should be some error checking. */
+ /* set the path prefix (directory) that should be used for the
+ pipes. at some point, there should be some error checking. */
strcpy(path_prefix,optarg);
break;
case 's':
@@ -3432,4 +3433,4 @@
};
}
}
-#endif /* WANT_UNIX */
+#endif /* WANT_UNIX */
More information about the netperf-dev
mailing list