#ifdef lint #define WANT_UNIX #define DIRTY #define WANT_INTERVALS #endif /* lint */ #ifdef HAVE_CONFIG_H #include #endif #ifdef WIN32 #error Unix Domain Sockets are not available under Windows #endif #ifdef WANT_UNIX char nettest_unix_id[]="\ @(#)nettest_unix.c (c) Copyright 1994-2012 Hewlett-Packard Co. Version 2.6.0"; /****************************************************************/ /* */ /* nettest_bsd.c */ /* */ /* the BSD sockets parsing routine... */ /* */ /* scan_unix_args() */ /* */ /* the actual test routines... */ /* */ /* send_stream_stream() perform a stream stream test */ /* recv_stream_stream() */ /* send_stream_rr() perform a stream request/response */ /* recv_stream_rr() */ /* send_dg_stream() perform a dg stream test */ /* recv_dg_stream() */ /* send_dg_rr() perform a dg request/response */ /* recv_dg_rr() */ /* loc_cpu_rate() determine the local cpu maxrate */ /* 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 */ #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef NOSTDLIBH #include #else /* NOSTDLIBH */ #include #endif /* NOSTDLIBH */ #include #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. */ #define UNIX_PRFX "netperf." #define UNIX_LENGTH_MAX 0xFFFF - 28 static char path_prefix[32]; static int 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 */ lss_size, /* local socket send buffer size */ lsr_size, /* local socket recv buffer size */ req_size = 1, /* request size */ rsp_size = 1, /* response size */ send_size, /* how big are individual sends */ recv_size; /* how big are individual receives */ /* different options for the sockets */ char unix_usage[] = "\n\ Usage: netperf [global options] -- [test options] \n\ \n\ STREAM/DG UNIX Sockets Test Options:\n\ -h Display this text\n\ -m bytes Set the send size (STREAM_STREAM, DG_STREAM)\n\ -M bytes Set the recv size (STREAM_STREAM, DG_STREAM)\n\ -p dir Set the directory where pipes are created\n\ -r req,res Set request,response size (STREAM_RR, DG_RR)\n\ -s send[,recv] Set local socket send/recv buffer sizes\n\ -S send[,recv] Set remote socket send/recv buffer sizes\n\ \n\ For those options taking two parms, at least one must be specified;\n\ specifying one value without a comma will set both parms to that\n\ value, specifying a value with a leading comma will set just the second\n\ parm, a value with a trailing comma will set just the first. To set\n\ each parm to unique values, specify both and separate them with a\n\ comma.\n"; /* this routing initializes all the test specific variables */ static void init_test_vars() { rss_size = 0; rsr_size = 0; lss_size_req = -1; lsr_size_req = -1; lss_size = 0; lsr_size = 0; req_size = 1; rsp_size = 1; send_size = 0; recv_size = 0; 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 */ SOCKET create_unix_socket(int family, int type) { SOCKET temp_socket; /*set up the data socket */ temp_socket = socket(family, type, 0); if (temp_socket == INVALID_SOCKET){ fprintf(where, "netperf: create_unix_socket: socket: %d\n", errno); 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. */ set_sock_buffer(temp_socket, SEND_BUFFER, lss_size_req, &lss_size); set_sock_buffer(temp_socket, RECV_BUFFER, lsr_size_req, &lsr_size); return(temp_socket); } /* 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 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. */ #ifdef DIRTY int *message_int_ptr; #endif #include 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... ;-) */ 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 = (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 = (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. */ 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) fprintf(where,cpu_title,format_units()); 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, 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... */ if (send_size == 0) { if (lss_size > 0) { send_size = lss_size; } else { send_size = 4096; } } /* set-up the data buffer ring with the requested alignment and offset. note also that we have allocated a quantity of memory that is at least one send-size greater than our socket buffer size. We want to be sure that there are at least two buffers allocated - this can be a bit of a problem when the send_size is bigger than the socket size, so we must check... the user may have wanted to explicitly set the "width" of our send buffers, we should respect that wish... */ if (send_width == 0) { send_width = (lss_size/send_size) + 1; if (send_width == 1) send_width++; } send_ring = allocate_buffer_ring(send_width, send_size, local_send_align, local_send_offset); /* If the user has requested cpu utilization measurements, we must calibrate the cpu(s). We will perform this task within the tests themselves. If the user has specified the cpu rate, then calibrate_local_cpu will return rather quickly as it will have nothing to do. If local_cpu_rate is zero, then we will go through all the "normal" calibration stuff and return the rate back.*/ if (local_cpu_usage) { local_cpu_rate = calibrate_local_cpu(local_cpu_rate); } /* Tell the remote end to do a listen. The server alters the socket paramters on the other side at this point, hence the reason for all the values being passed in the setup message. If the user did not specify any of the parameters, they will be passed as 0, which will indicate to the remote that no changes beyond the system's default should be used. Alignment is the exception, it will default to 1, which will be no alignment alterations. */ netperf_request.content.request_type = DO_STREAM_STREAM; stream_stream_request->send_buf_size = rss_size; stream_stream_request->recv_buf_size = rsr_size; stream_stream_request->receive_size = recv_size; stream_stream_request->recv_alignment = remote_recv_align; stream_stream_request->recv_offset = remote_recv_offset; stream_stream_request->measure_cpu = remote_cpu_usage; stream_stream_request->cpu_rate = remote_cpu_rate; if (test_time) { stream_stream_request->test_length = test_time; } else { stream_stream_request->test_length = test_bytes; } #ifdef DIRTY 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. */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"remote listen done.\n"); rsr_size = stream_stream_response->recv_buf_size; rss_size = stream_stream_response->send_buf_size; remote_cpu_usage = stream_stream_response->measure_cpu; remote_cpu_rate = stream_stream_response->cpu_rate; strcpy(server.sun_path,stream_stream_response->unix_path); } else { Set_errno(netperf_response.content.serv_errno); perror("netperf: send_stream_stream: remote error"); exit(1); } /*Connect up to the remote port on the data 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. */ if (test_time) { /* The user wanted to end the test after a period of time. */ times_up = 0; bytes_remaining = 0; start_timer(test_time); } else { /* The tester wanted to send a number of bytes. */ bytes_remaining = test_bytes; times_up = 1; } /* The cpu_start routine will grab the current time and possibly value of the idle counter for later use in measuring cpu utilization and/or service demand and thruput. */ cpu_start(local_cpu_usage); /* 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 */ 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. */ message_int_ptr = (int *)(send_ring->buffer_ptr); for (i = 0; i < loc_dirty_count; i++) { *message_int_ptr = rand(); message_int_ptr++; } for (i = 0; i < loc_clean_count; i++) { loc_dirty_count = *message_int_ptr; message_int_ptr++; } #endif /* DIRTY */ if((len=send(send_socket, send_ring->buffer_ptr, send_size, 0)) != send_size) { if ((len >=0) || (errno == EINTR)) { /* the test was interrupted, must be the end of test */ break; } perror("netperf: data send error"); printf("len was %d\n",len); exit(1); } #ifdef WANT_INTERVALS for (interval_count = 0; 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++; 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. */ 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. */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"remote results obtained\n"); } 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 ;-) */ 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...*/ 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, 0.0, 0); } else { 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"); fprintf(where,"Remote CPU usage numbers based on process information only!\n"); fflush(where); } remote_cpu_utilization = stream_stream_result->cpu_util; remote_service_demand = calc_service_demand(bytes_sent, 0.0, remote_cpu_utilization, stream_stream_result->num_cpus); } else { 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... */ switch (verbosity) { case 0: if (local_cpu_usage) { fprintf(where, cpu_fmt_0, local_service_demand); } else { fprintf(where, cpu_fmt_0, remote_service_demand); } break; case 1: case 2: fprintf(where, cpu_fmt_1, /* the format string */ rsr_size, /* remote recvbuf size */ lss_size, /* local sendbuf size */ send_size, /* how large were the sends */ elapsed_time, /* how long was the test */ thruput, /* what was the xfer rate */ local_cpu_utilization, /* local cpu */ remote_cpu_utilization, /* remote cpu */ local_service_demand, /* local service demand */ remote_service_demand); /* remote service demand */ break; } } else { /* The tester did not wish to measure service demand. */ switch (verbosity) { case 0: fprintf(where, tput_fmt_0, thruput); break; case 1: case 2: fprintf(where, tput_fmt_1, /* the format string */ rsr_size, /* remote recvbuf size */ lss_size, /* local sendbuf size */ send_size, /* how large were the sends */ elapsed_time, /* how long did it take */ thruput); /* how fast did it go */ break; } } /* it would be a good thing to include information about some of the other parameters that may have been set for this test, but at the moment, I do not wish to figure-out all the formatting, so I will just put this comment here to help remind me that it is something that should be done at a later time. */ if (verbosity > 1) { /* The user wanted to know it all, so we will give it to him. This information will include as much as we can find about STREAM statistics, the alignments of the sends and receives and all that sort of rot... */ fprintf(where, ksink_fmt, "Bytes", "Bytes", "Bytes", local_send_align, remote_recv_align, local_send_offset, remote_recv_offset, bytes_sent, bytes_sent / (double)nummessages, nummessages, bytes_sent / (double)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. */ void recv_stream_stream() { struct sockaddr_un myaddr_un, peeraddr_un; SOCKET s_listen,s_data; netperf_socklen_t addrlen; int len; int receive_calls = 0; float elapsed_time; int bytes_received; struct ring_elt *recv_ring; #ifdef DIRTY char *message_ptr; int *message_int_ptr; int dirty_count; 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 = (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_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. */ 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. */ 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. */ 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 */ 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. */ strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf.")); if (debug) { fprintf(where,"selected a path of %s\n",myaddr_un.sun_path); fflush(where); } if (bind(s_listen, (struct sockaddr *)&myaddr_un, sizeof(myaddr_un)) == SOCKET_ERROR) { netperf_response.content.serv_errno = errno; 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? */ if (stream_stream_request->receive_size == 0) { if (lsr_size > 0) { recv_size = lsr_size; } else { recv_size = 4096; } } 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 */ if (recv_width == 0) { recv_width = (lsr_size/recv_size) + 1; if (recv_width == 1) recv_width++; } recv_ring = allocate_buffer_ring(recv_width, recv_size, stream_stream_request->recv_alignment, stream_stream_request->recv_offset); if (debug) { 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, (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. */ 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. */ 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 = 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 */ 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) { /* Let's just punt. The remote will be given some information */ 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. */ cpu_start(stream_stream_request->measure_cpu); /* The loop will exit when the sender does a shutdown, which will return a length of zero */ #ifdef DIRTY /* we want to dirty some number of consecutive integers in the buffer we are about to recv. we may also want to bring some number of them cleanly into the cache. The clean ones will follow any dirty ones into the cache. */ dirty_count = stream_stream_request->dirty_count; clean_count = stream_stream_request->clean_count; message_int_ptr = (int *)recv_ring->buffer_ptr; for (i = 0; i < dirty_count; i++) { *message_int_ptr = rand(); message_int_ptr++; } for (i = 0; i < clean_count; i++) { dirty_count = *message_int_ptr; message_int_ptr++; } #endif /* DIRTY */ bytes_received = 0; while ((len = recv(s_data, recv_ring->buffer_ptr, recv_size, 0)) != 0) { if (len == SOCKET_ERROR) { netperf_response.content.serv_errno = errno; send_response(); exit(1); } bytes_received += len; receive_calls++; /* more to the next buffer in the recv_ring */ recv_ring = recv_ring->next; #ifdef DIRTY message_int_ptr = (int *)(recv_ring->buffer_ptr); for (i = 0; i < dirty_count; i++) { *message_int_ptr = rand(); message_int_ptr++; } for (i = 0; i < clean_count; i++) { dirty_count = *message_int_ptr; message_int_ptr++; } #endif /* DIRTY */ } /* 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 */ 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", bytes_received); fprintf(where, "recv_stream_stream: got %d recvs\n", 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. */ 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; SOCKET send_socket; int trans_remaining; double bytes_xferd; struct ring_elt *send_ring; struct ring_elt *recv_ring; int rsp_bytes_left; int rsp_bytes_recvd; float local_cpu_utilization; float local_service_demand; float remote_cpu_utilization; float remote_service_demand; double thruput; struct sockaddr_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 = (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. */ 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) fprintf(where,cpu_title,format_units()); 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 */ 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, local_send_offset); recv_ring = allocate_buffer_ring(recv_width, rsp_size, local_recv_align, local_recv_offset); /*set up the data socket */ 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 (local_cpu_usage) { local_cpu_rate = calibrate_local_cpu(local_cpu_rate); } /* Tell the remote end to do a listen. The server alters the socket paramters on the other side at this point, hence the reason for all the values being passed in the setup message. If the user did not specify any of the parameters, they will be passed as 0, which will indicate to the remote that no changes beyond the system's default should be used. Alignment is the exception, it will default to 8, which will be no alignment alterations. */ netperf_request.content.request_type = DO_STREAM_RR; stream_rr_request->recv_buf_size = rsr_size; stream_rr_request->send_buf_size = rss_size; stream_rr_request->recv_alignment= remote_recv_align; stream_rr_request->recv_offset = remote_recv_offset; stream_rr_request->send_alignment= remote_send_align; stream_rr_request->send_offset = remote_send_offset; stream_rr_request->request_size = req_size; stream_rr_request->response_size = rsp_size; stream_rr_request->measure_cpu = remote_cpu_usage; stream_rr_request->cpu_rate = remote_cpu_rate; if (test_time) { stream_rr_request->test_length = test_time; } 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. */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"remote listen done.\n"); rsr_size = stream_rr_response->recv_buf_size; rss_size = stream_rr_response->send_buf_size; remote_cpu_usage= stream_rr_response->measure_cpu; remote_cpu_rate = stream_rr_response->cpu_rate; /* make sure that port numbers are in network order */ strcpy(server.sun_path,stream_rr_response->unix_path); } 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, (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. */ if (test_time) { /* The user wanted to end the test after a period of time. */ times_up = 0; trans_remaining = 0; start_timer(test_time); } else { /* The tester wanted to send a number of bytes. */ trans_remaining = test_bytes; times_up = 1; } /* The cpu_start routine will grab the current time and possibly value of the idle counter for later use in measuring cpu utilization and/or service demand and thruput. */ cpu_start(local_cpu_usage); /* 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. */ if((len=send(send_socket, send_ring->buffer_ptr, req_size, 0)) != req_size) { if (errno == EINTR) { /* we hit the end of a timed test. */ timed_out = 1; break; } perror("send_stream_rr: data send error"); exit(1); } send_ring = send_ring->next; /* receive the response */ rsp_bytes_left = rsp_size; temp_message_ptr = recv_ring->buffer_ptr; while(rsp_bytes_left > 0) { if((rsp_bytes_recvd=recv(send_socket, temp_message_ptr, rsp_bytes_left, 0)) == SOCKET_ERROR) { if (errno == EINTR) { /* We hit the end of a timed test. */ timed_out = 1; break; } perror("send_stream_rr: data recv error"); exit(1); } rsp_bytes_left -= rsp_bytes_recvd; temp_message_ptr += rsp_bytes_recvd; } recv_ring = recv_ring->next; if (timed_out) { /* we may have been in a nested while loop - we need another call to break. */ break; } nummessages++; if (trans_remaining) { trans_remaining--; } if (debug > 3) { fprintf(where, "Transaction %d completed\n", nummessages); fflush(where); } } /* At this point we used to call shutdown on the data socket to be sure all the data was delivered, but this was not germane in a request/response test, and it was causing the tests to "hang" when they were being controlled by time. So, I have replaced this shutdown call with a call to close that can be found later in the procedure. */ /* this call will always give us the elapsed time for the test, and will also store-away the necessaries for cpu utilization */ cpu_stop(local_cpu_usage,&elapsed_time); /* was cpu being measured? how long did we really run? */ /* Get the statistics from the remote end. The remote will have calculated service demand and all those interesting things. If it wasn't supposed to care, it will return obvious values. */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"remote results obtained\n"); } else { Set_errno(netperf_response.content.serv_errno); 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. */ 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...*/ 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); /* since calc_service demand is doing ms/Kunit we will multiply the number of transaction by 1024 to get "good" numbers */ local_service_demand = calc_service_demand((double) nummessages*1024, 0.0, 0.0, 0); } else { local_cpu_utilization = -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"); fprintf(where,"Remote CPU usage numbers based on process information only!\n"); 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 */ remote_service_demand = calc_service_demand((double) nummessages*1024, 0.0, remote_cpu_utilization, stream_rr_result->num_cpus); } else { 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... */ switch (verbosity) { case 0: if (local_cpu_usage) { fprintf(where, cpu_fmt_0, local_service_demand); } else { fprintf(where, cpu_fmt_0, remote_service_demand); } break; case 1: fprintf(where, cpu_fmt_1_line_1, /* the format string */ lss_size, /* local sendbuf size */ lsr_size, req_size, /* how large were the requests */ rsp_size, /* guess */ elapsed_time, /* how long was the test */ nummessages/elapsed_time, local_cpu_utilization, /* local cpu */ remote_cpu_utilization, /* remote cpu */ local_service_demand, /* local service demand */ remote_service_demand); /* remote service demand */ fprintf(where, cpu_fmt_1_line_2, rss_size, rsr_size); break; } } else { /* The tester did not wish to measure service demand. */ switch (verbosity) { case 0: fprintf(where, tput_fmt_0, nummessages/elapsed_time); break; case 1: fprintf(where, tput_fmt_1_line_1, /* the format string */ lss_size, lsr_size, req_size, /* how large were the requests */ rsp_size, /* how large were the responses */ elapsed_time, /* how long did it take */ nummessages/elapsed_time); fprintf(where, tput_fmt_1_line_2, rss_size, /* remote recvbuf size */ rsr_size); break; } } /* it would be a good thing to include information about some of the other parameters that may have been set for this test, but at the moment, I do not wish to figure-out all the formatting, so I will just put this comment here to help remind me that it is something that should be done at a later time. */ 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... */ 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, 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 */ #ifdef DIRTY 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. */ 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) printf(cpu_title,format_units()); 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) { send_size = (lss_size < UNIX_LENGTH_MAX ? lss_size : UNIX_LENGTH_MAX); } else { 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. */ if (send_width == 0) send_width = 32; send_ring = allocate_buffer_ring(send_width, send_size, 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?) */ 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. */ netperf_request.content.request_type = DO_DG_STREAM; dg_stream_request->recv_buf_size = rsr_size; dg_stream_request->message_size = send_size; dg_stream_request->recv_alignment = remote_recv_align; dg_stream_request->recv_offset = remote_recv_offset; 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"); } else { Set_errno(netperf_response.content.serv_errno); 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. */ /* 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... */ 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 */ 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... */ 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. */ message_int_ptr = (int *)(send_ring->buffer_ptr); for (i = 0; i < loc_dirty_count; i++) { *message_int_ptr = 4; message_int_ptr++; } for (i = 0; i < loc_clean_count; i++) { loc_dirty_count = *message_int_ptr; message_int_ptr++; } #endif /* DIRTY */ if ((len=send(data_socket, send_ring->buffer_ptr, send_size, 0)) != send_size) { if ((len >= 0) || (errno == EINTR)) break; if (errno == ENOBUFS) { failed_sends++; continue; } 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... */ 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 */ 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. */ 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. */ /* the test is over, so get stats and stuff */ cpu_stop(local_cpu_usage, &elapsed_time); /* Get the statistics from the remote end */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"send_dg_stream: remote results obtained\n"); } else { Set_errno(netperf_response.content.serv_errno); 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. */ 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, 0.0, 0); } else { 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. */ 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, remote_cpu_utilization, dg_stream_results->num_cpus); } else { 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... */ switch (verbosity) { case 0: if (local_cpu_usage) { fprintf(where, cpu_fmt_0, local_service_demand); } else { fprintf(where, cpu_fmt_0, remote_service_demand); } 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 */ messages_sent, failed_sends, local_thruput, /* what was the xfer rate */ local_cpu_utilization,/* local cpu */ local_service_demand, /* local service demand */ rsr_size, elapsed_time, messages_recvd, remote_thruput, remote_cpu_utilization, /* remote cpu */ remote_service_demand); /* remote service demand */ break; } } else { /* The tester did not wish to measure service demand. */ switch (verbosity) { case 0: fprintf(where, tput_fmt_0, local_thruput); break; case 1: fprintf(where, tput_fmt_1, /* the format string */ lss_size, /* local sendbuf size */ send_size, /* how large were the sends */ elapsed_time, /* how long did it take */ messages_sent, failed_sends, local_thruput, rsr_size, /* remote recvbuf size */ elapsed_time, messages_recvd, remote_thruput ); break; } } } /* this routine implements the receive side (netserver) of the DG_STREAM performance test. */ void recv_dg_stream() { struct ring_elt *recv_ring; struct sockaddr_un myaddr_un; SOCKET s_data; 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 = (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; 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. */ 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. */ if (debug > 1) { fprintf(where,"recv_dg_stream: requested alignment of %d\n", dg_stream_request->recv_alignment); fflush(where); } if (recv_width == 0) recv_width = 1; recv_ring = allocate_buffer_ring(recv_width, dg_stream_request->message_size, dg_stream_request->recv_alignment, dg_stream_request->recv_offset); if (debug > 1) { 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. */ 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 */ 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. */ strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf.")); if (bind(s_data, (struct sockaddr *)&myaddr_un, sizeof(myaddr_un)) == SOCKET_ERROR) { netperf_response.content.serv_errno = errno; send_response(); exit(1); } 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. */ 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. */ 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... */ dg_stream_response->measure_cpu = 1; 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 */ 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. */ 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... */ 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, recv_ring->buffer_ptr, message_size, 0)) != message_size) { if ((len == SOCKET_ERROR) && (errno != EINTR)) { netperf_response.content.serv_errno = errno; send_response(); exit(1); } break; } 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; } 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; dg_stream_results->elapsed_time = elapsed_time; if (dg_stream_request->measure_cpu) { dg_stream_results->cpu_util = calc_cpu_util(elapsed_time); } 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.*/ int len; char *send_message_ptr; char *recv_message_ptr; char *temp_message_ptr; int nummessages; 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 int time_index = 0; int unused_buckets; int kept_times[MAX_KEPT_TIMES]; int sleep_usecs; unsigned int total_times=0; struct timezone dummy_zone; struct timeval send_time; 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 = (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; while (time_index < MAX_KEPT_TIMES) { kept_times[time_index] = 0; time_index += 1; } 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. */ bzero((char *)&server, sizeof(server)); server.sun_family = AF_UNIX; bzero((char *)&myaddr_un, sizeof(myaddr_un)); 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) fprintf(where,cpu_title,format_units()); 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 + (long) local_send_align - 1) & ~((long) local_send_align - 1)); send_message_ptr = send_message_ptr + local_send_offset; temp_message_ptr = (char *)malloc(DATABUFFERLEN); if (temp_message_ptr == NULL) { printf("malloc(%d) failed!\n", DATABUFFERLEN); exit(1); } 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, 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 (local_cpu_usage) { local_cpu_rate = calibrate_local_cpu(local_cpu_rate); } /* Tell the remote end to do a listen. The server alters the socket paramters on the other side at this point, hence the reason for all the values being passed in the setup message. If the user did not specify any of the parameters, they will be passed as 0, which will indicate to the remote that no changes beyond the system's default should be used. Alignment is the exception, it will default to 8, which will be no alignment alterations. */ netperf_request.content.request_type = DO_DG_RR; dg_rr_request->recv_buf_size = rsr_size; dg_rr_request->send_buf_size = rss_size; dg_rr_request->recv_alignment = remote_recv_align; dg_rr_request->recv_offset = remote_recv_offset; dg_rr_request->send_alignment = remote_send_align; dg_rr_request->send_offset = remote_send_offset; dg_rr_request->request_size = req_size; dg_rr_request->response_size = rsp_size; dg_rr_request->measure_cpu = remote_cpu_usage; dg_rr_request->cpu_rate = remote_cpu_rate; if (test_time) { dg_rr_request->test_length = test_time; } 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. */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"remote listen done.\n"); rsr_size = dg_rr_response->recv_buf_size; rss_size = dg_rr_response->send_buf_size; remote_cpu_usage= dg_rr_response->measure_cpu; remote_cpu_rate = dg_rr_response->cpu_rate; /* port numbers in proper order */ strcpy(server.sun_path,dg_rr_response->unix_path); } 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 */ if (bind(send_socket, (struct sockaddr *)&myaddr_un, sizeof(myaddr_un)) == SOCKET_ERROR) { perror("netperf: send_dg_rr"); unlink(myaddr_un.sun_path); close(send_socket); exit(1); } 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. */ if (test_time) { /* The user wanted to end the test after a period of time. */ times_up = 0; trans_remaining = 0; start_timer(test_time); } else { /* The tester wanted to send a number of bytes. */ trans_remaining = test_bytes; times_up = 1; } /* The cpu_start routine will grab the current time and possibly value of the idle counter for later use in measuring cpu utilization and/or service demand and thruput. */ cpu_start(local_cpu_usage); /* 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 gettimeofday(&send_time,&dummy_zone); #endif if((len=send(send_socket, send_message_ptr, req_size, 0)) != req_size) { if (errno == EINTR) { /* We likely hit */ /* test-end time. */ break; } 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, 0)) != rsp_size) { if (errno == EINTR) { /* Again, we have likely hit test-end time */ break; } perror("send_dg_rr: data recv error"); exit(1); } #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. */ if (interval_usecs > 0) { sleep_usecs = interval_usecs - kept_times[time_index]; if (sleep_usecs > 1000) { /* we sleep */ sleep_timeval.tv_sec = sleep_usecs / 1000000; sleep_timeval.tv_usec = sleep_usecs % 1000000; select(0, 0, 0, 0, &sleep_timeval); } } /* now up the time index */ time_index = (time_index +1)%MAX_KEPT_TIMES; #endif 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 ;-) */ 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. */ recv_response(); if (!netperf_response.content.serv_errno) { if (debug) fprintf(where,"remote results obtained\n"); } 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 */ 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...*/ 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); /* since calc_service demand is doing ms/Kunit we will multiply the number of transaction by 1024 to get "good" numbers */ local_service_demand = calc_service_demand((double) nummessages*1024, 0.0, 0.0, 0); } else { local_cpu_utilization = -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"); fprintf(where,"Remote CPU usage numbers based on process information only!\n"); 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 */ remote_service_demand = calc_service_demand((double) nummessages*1024, 0.0, remote_cpu_utilization, dg_rr_result->num_cpus); } else { 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... */ switch (verbosity) { case 0: if (local_cpu_usage) { fprintf(where, cpu_fmt_0, local_service_demand); } else { fprintf(where, cpu_fmt_0, remote_service_demand); } break; case 1: case 2: fprintf(where, cpu_fmt_1_line_1, /* the format string */ lss_size, /* local sendbuf size */ lsr_size, req_size, /* how large were the requests */ rsp_size, /* guess */ elapsed_time, /* how long was the test */ nummessages/elapsed_time, local_cpu_utilization, /* local cpu */ remote_cpu_utilization, /* remote cpu */ local_service_demand, /* local service demand */ remote_service_demand); /* remote service demand */ fprintf(where, cpu_fmt_1_line_2, rss_size, rsr_size); break; } } else { /* The tester did not wish to measure service demand. */ switch (verbosity) { case 0: fprintf(where, tput_fmt_0, nummessages/elapsed_time); break; case 1: case 2: fprintf(where, tput_fmt_1_line_1, /* the format string */ lss_size, lsr_size, req_size, /* how large were the requests */ rsp_size, /* how large were the responses */ elapsed_time, /* how long did it take */ nummessages/elapsed_time); fprintf(where, tput_fmt_1_line_2, rss_size, /* remote recvbuf size */ rsr_size); break; } } /* it would be a good thing to include information about some of the other parameters that may have been set for this test, but at the moment, I do not wish to figure-out all the formatting, so I will just put this comment here to help remind me that it is something that should be done at a later time. */ 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... */ #ifdef WANT_INTERVALS kept_times[MAX_KEPT_TIMES] = 0; time_index = 0; while (time_index < MAX_KEPT_TIMES) { if (kept_times[time_index] > 0) { total_times += kept_times[time_index]; } else unused_buckets++; time_index += 1; } total_times /= (MAX_KEPT_TIMES-unused_buckets); fprintf(where, "Average response time %d usecs\n", total_times); #endif } unlink(myaddr_un.sun_path); } /* 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; struct sockaddr_un myaddr_un, peeraddr_un; SOCKET s_data; netperf_socklen_t addrlen; 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 = (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_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. */ 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. */ if (debug) { fprintf(where,"recv_dg_rr: requested recv alignment of %d offset %d\n", dg_rr_request->recv_alignment, dg_rr_request->recv_offset); fprintf(where,"recv_dg_rr: requested send alignment of %d offset %d\n", dg_rr_request->send_alignment, dg_rr_request->send_offset); fflush(where); } if (send_width == 0) send_width = 1; if (recv_width == 0) recv_width = 1; recv_ring = allocate_buffer_ring(recv_width, dg_rr_request->request_size, dg_rr_request->recv_alignment, dg_rr_request->recv_offset); send_ring = allocate_buffer_ring(send_width, dg_rr_request->response_size, dg_rr_request->send_alignment, dg_rr_request->send_offset); if (debug) { 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. */ 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 */ 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. */ strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf.")); if (bind(s_data, (struct sockaddr *)&myaddr_un, sizeof(myaddr_un)) == SOCKET_ERROR) { netperf_response.content.serv_errno = errno; 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. */ 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. */ 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 */ 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. */ cpu_start(dg_rr_request->measure_cpu); if (dg_rr_request->test_length > 0) { times_up = 0; trans_remaining = 0; start_timer(dg_rr_request->test_length + PAD_TIME); } else { 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, recv_ring->buffer_ptr, dg_rr_request->request_size); fflush(where); if (recvfrom(s_data, recv_ring->buffer_ptr, dg_rr_request->request_size, 0, (struct sockaddr *)&peeraddr_un, &addrlen) != dg_rr_request->request_size) { if (errno == EINTR) { /* we must have hit the end of test time. */ break; } netperf_response.content.serv_errno = errno; fprintf(where,"error on recvfrom errno %d\n",errno); fflush(where); send_response(); unlink(myaddr_un.sun_path); exit(1); } recv_ring = recv_ring->next; /* Now, send the response to the remote */ if (sendto(s_data, send_ring->buffer_ptr, dg_rr_request->response_size, 0, (struct sockaddr *)&peeraddr_un, addrlen) != dg_rr_request->response_size) { if (errno == EINTR) { /* we have hit end of test time. */ break; } netperf_response.content.serv_errno = errno; fprintf(where,"error on recvfrom errno %d\n",errno); fflush(where); unlink(myaddr_un.sun_path); send_response(); 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 */ 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. */ 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_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 */ void recv_stream_rr() { struct ring_elt *send_ring; struct ring_elt *recv_ring; struct sockaddr_un myaddr_un, peeraddr_un; SOCKET s_listen,s_data; netperf_socklen_t addrlen; char *temp_message_ptr; int trans_received = 0; int trans_remaining; int bytes_sent; int request_bytes_recvd; 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 = (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. */ 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 */ if (debug) { fprintf(where,"recv_stream_rr: requested recv alignment of %d offset %d\n", stream_rr_request->recv_alignment, stream_rr_request->recv_offset); fprintf(where,"recv_stream_rr: requested send alignment of %d offset %d\n", stream_rr_request->send_alignment, stream_rr_request->send_offset); fflush(where); } /* at some point, these need to come to us from the remote system */ if (send_width == 0) send_width = 1; if (recv_width == 0) recv_width = 1; send_ring = allocate_buffer_ring(send_width, stream_rr_request->response_size, stream_rr_request->send_alignment, stream_rr_request->send_offset); recv_ring = allocate_buffer_ring(recv_width, stream_rr_request->request_size, 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. */ 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 */ 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. */ strcpy(myaddr_un.sun_path,tempnam(path_prefix,"netperf.")); if (bind(s_listen, (struct sockaddr *)&myaddr_un, sizeof(myaddr_un)) == SOCKET_ERROR) { netperf_response.content.serv_errno = errno; 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. */ 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. */ 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 */ 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. */ cpu_start(stream_rr_request->measure_cpu); /* 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; start_timer(stream_rr_request->test_length + PAD_TIME); } else { 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); fprintf(where,"temp_message_ptr is %p\n",temp_message_ptr); fflush(where); } while(request_bytes_remaining > 0) { if((request_bytes_recvd=recv(s_data, temp_message_ptr, request_bytes_remaining, 0)) == SOCKET_ERROR) { if (errno == EINTR) { /* the timer popped */ timed_out = 1; break; } netperf_response.content.serv_errno = errno; send_response(); exit(1); } else { request_bytes_remaining -= request_bytes_recvd; temp_message_ptr += request_bytes_recvd; } if (debug) { fprintf(where,"just received for trans %d\n",trans_received); fflush(where); } } recv_ring = recv_ring->next; if (timed_out) { /* 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); fflush(where); } if((bytes_sent=send(s_data, send_ring->buffer_ptr, stream_rr_request->response_size, 0)) == SOCKET_ERROR) { if (errno == EINTR) { /* the test timer has popped */ timed_out = 1; fprintf(where,"yo6\n"); fflush(where); break; } netperf_response.content.serv_errno = 997; 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", trans_received); fflush(where); } } /* 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. */ 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_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); } void print_unix_usage() { fwrite(unix_usage, sizeof(char), strlen(unix_usage), stdout); exit(1); } void scan_unix_args(int argc, char *argv[]) { #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) { fprintf(where, "The UNIX tests do not know how to run with no control connection\n"); 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.. */ while ((c= getopt(argc, argv, UNIX_ARGS)) != EOF) { switch (c) { case '?': case 'h': 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. */ strcpy(path_prefix,optarg); break; case 's': /* set local socket sizes */ break_args(optarg,arg1,arg2); if (arg1[0]) lss_size_req = convert(arg1); if (arg2[0]) lsr_size_req = convert(arg2); break; case 'S': /* set remote socket sizes */ break_args(optarg,arg1,arg2); if (arg1[0]) rss_size = convert(arg1); if (arg2[0]) rsr_size = convert(arg2); break; case 'r': /* set the request/response sizes */ break_args(optarg,arg1,arg2); if (arg1[0]) req_size = convert(arg1); if (arg2[0]) rsp_size = convert(arg2); break; case 'm': /* set the send size */ send_size = convert(optarg); break; case 'M': /* set the recv size */ recv_size = convert(optarg); break; }; } } #endif /* WANT_UNIX */