C++程序
|
7491行
|
220.22 KB
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifdef WANT_OMNI
char nettest_omni_id[]="\
@(#)nettest_omni.c (c) Copyright 2008-2012 Hewlett-Packard Co. Version 2.6.0";
#include <stdio.h>
#if HAVE_SYS_TYPES_H
# include <sys/types.h>
#endif
#if HAVE_SYS_STAT_H
# include <sys/stat.h>
#endif
#if STDC_HEADERS
# include <stdlib.h>
# include <stddef.h>
#else
# if HAVE_STDLIB_H
# include <stdlib.h>
# endif
#endif
#if HAVE_STRING_H
# if !STDC_HEADERS && HAVE_MEMORY_H
# include <memory.h>
# endif
# include <string.h>
#endif
#if HAVE_STRINGS_H
# include <strings.h>
#endif
#if HAVE_INTTYPES_H
# include <inttypes.h>
#else
# if HAVE_STDINT_H
# include <stdint.h>
# endif
#endif
#if HAVE_UNISTD_H
# include <unistd.h>
#endif
#if HAVE_SYS_IOCTL_H
# include <sys/ioctl.h>
#endif
#if HAVE_SCHED_H
# include <sched.h>
#endif
#include <fcntl.h>
#ifndef WIN32
#include <errno.h>
#include <signal.h>
#endif
#if TIME_WITH_SYS_TIME
# include <sys/time.h>
# include <time.h>
#else
# if HAVE_SYS_TIME_H
# include <sys/time.h>
# else
# include <time.h>
# endif
#endif
#include <ctype.h>
#ifdef NOSTDLIBH
#include <malloc.h>
#endif /* NOSTDLIBH */
#include <assert.h>
#ifndef WIN32
#include <sys/socket.h>
#include <netinet/in.h>
/* it would seem that including both <netinet/tcp.h> and <linux/tcp.h>
is not a path to happiness and joy when one wishes to grab tcp_info
stats and not get something like the compiler complaining about
either redefinitions, or missing tcpi_total_retrans. */
#ifdef HAVE_LINUX_TCP_H
#include <linux/tcp.h>
#else
#include <netinet/tcp.h>
#endif
/* this is to get us the definition of MSG_FASTOPEN. we may need to
cheat just a litle at first */
#ifdef HAVE_LINUX_SOCKET_H
# include <linux/socket.h>
# ifndef MSG_FASTOPEN
# warning Using our own value for MSG_FASTOPEN
# define MSG_FASTOPEN 0x20000000 /* Send data in TCP SYN */
# endif
# ifndef TCP_FASTOPEN
# warning Using our own value for TCP_FASTOPEN
# define TCP_FASTOPEN 23
# endif
#endif
#ifdef HAVE_NETINET_SCTP_H
#include <netinet/sctp.h>
#endif
#include <arpa/inet.h>
#include <netdb.h>
#else /* WIN32 */
#include <process.h>
#define netperf_socklen_t socklen_t
#include <winsock2.h>
/* while it is unlikely that anyone running Windows 2000 or NT 4 is
going to be trying to compile this, if they are they will want to
define DONT_IPV6 in the sources file */
#ifndef DONT_IPV6
#include <ws2tcpip.h>
#endif
#include <windows.h>
#define sleep(x) Sleep((x)*1000)
#include "missing\stdint.h"
#endif /* WIN32 */
/* We don't want to use bare constants in the shutdown() call. In the
extremely unlikely event that SHUT_WR isn't defined, we will define
it to the value we used to be passing to shutdown() anyway. raj
2007-02-08 */
#if !defined(SHUT_WR)
#define SHUT_WR 1
#endif
#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO)
# include "missing/getaddrinfo.h"
#endif
#include "netlib.h"
#include "netsh.h"
#include "nettest_bsd.h"
/* we only really use this once, but the initial patch to
src/nettest_bsd.c used it in several places. keep it as a macro
just for kicks and just in case we do end-up needing to use it
multiple times. */
#define WAIT_BEFORE_DATA_TRAFFIC() \
{ \
if (wait_time_secs) \
sleep(wait_time_secs); \
} \
/* since someone can ask for latency stats, we will always include
this and do the other other things */
#include "hist.h"
static HIST time_hist;
#ifdef WANT_INTERVALS
int interval_count;
unsigned int interval_wait_microseconds;
/* hoist the timestamps up here so we can use them to factor-out the
time spent "waiting" */
/* first out timestamp */
#ifdef HAVE_GETHRTIME
static hrtime_t intvl_one;
static hrtime_t intvl_two;
static hrtime_t intvl_wait_start;
static hrtime_t *intvl_one_ptr = &intvl_one;
static hrtime_t *intvl_two_ptr = &intvl_two;
static hrtime_t *temp_intvl_ptr = &intvl_one;
#elif defined(WIN32)
static LARGE_INTEGER intvl_one;
static LARGE_INTEGER intvl_two;
static LARGE_INTEGER intvl_wait_start;
static LARGE_INTEGER *intvl_one_ptr = &intvl_one;
static LARGE_INTEGER *intvl_two_ptr = &intvl_two;
static LARGE_INTEGER *temp_intvl_ptr = &intvl_one;
#else
static struct timeval intvl_one;
static struct timeval intvl_two;
static struct timeval intvl_wait_start;
static struct timeval *intvl_one_ptr = &intvl_one;
static struct timeval *intvl_two_ptr = &intvl_two;
static struct timeval *temp_intvl_ptr = &intvl_one;
#endif
#ifndef WANT_SPIN
#ifdef WIN32
#define INTERVALS_INIT() \
if (interval_burst) { \
/* zero means that we never pause, so we never should need the \
interval timer. we used to use it for demo mode, but we deal \
with that with a variant on watching the clock rather than \
waiting for a timer. raj 2006-02-06 */ \
start_itimer(interval_wate); \
} \
interval_count = interval_burst; \
interval_wait_microseconds = 0;
#else
sigset_t signal_set;
#define INTERVALS_INIT() \
if (interval_burst) { \
/* zero means that we never pause, so we never should need the \
interval timer. we used to use it for demo mode, but we deal \
with that with a variant on watching the clock rather than \
waiting for a timer. raj 2006-02-06 */ \
start_itimer(interval_wate); \
} \
interval_count = interval_burst; \
interval_wait_microseconds = 0; \
/* get the signal set for the call to sigsuspend */ \
if (sigprocmask(SIG_BLOCK, (sigset_t *)NULL, &signal_set) != 0) { \
fprintf(where, \
"%s: unable to get sigmask errno %d\n", \
__FUNCTION__, \
errno); \
fflush(where); \
exit(1); \
}
#endif /* WIN32 */
#ifdef WIN32
#define INTERVALS_WAIT() \
/* in this case, the interval count is the count-down counter \
to decide to sleep for a little bit */ \
if ((interval_burst) && (--interval_count == 0)) { \
/* call WaitForSingleObject and wait for the interval timer to get us \
out */ \
if (debug > 1) { \
fprintf(where,"about to suspend\n"); \
fflush(where); \
} \
HIST_timestamp(&intvl_wait_start); \
if (WaitForSingleObject(WinTimer, INFINITE) != WAIT_OBJECT_0) { \
fprintf(where, "WaitForSingleObject failed (%d)\n", GetLastError()); \
fflush(where); \
exit(1); \
} \
HIST_timestamp(&intvl_two); \
interval_wait_microseconds += \
delta_micro(&intvl_wait_start,&intvl_two); \
interval_count = interval_burst; \
}
#else
#define INTERVALS_WAIT() \
/* in this case, the interval count is the count-down couter \
to decide to sleep for a little bit */ \
if ((interval_burst) && (--interval_count == 0)) { \
/* call sigsuspend and wait for the interval timer to get us \
out */ \
if (debug > 1) { \
fprintf(where,"about to suspend\n"); \
fflush(where); \
} \
HIST_timestamp(&intvl_wait_start); \
if (sigsuspend(&signal_set) == EFAULT) { \
fprintf(where, \
"%s: fault with sigsuspend.\n", \
__FUNCTION__); \
fflush(where); \
exit(1); \
} \
HIST_timestamp(&intvl_two); \
interval_wait_microseconds += \
delta_micro(&intvl_wait_start,&intvl_two); \
interval_count = interval_burst; \
}
#endif /* WIN32 */
#else
#define INTERVALS_INIT() \
if (interval_burst) { \
HIST_timestamp(intvl_one_ptr); \
} \
interval_wait_microseconds = 0; \
interval_count = interval_burst; \
#define INTERVALS_WAIT() \
/* 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)) { \
/* spin and wait for the interval timer to get us \
out */ \
if (debug > 1) { \
fprintf(where,"about to spin suspend\n"); \
fflush(where); \
} \
\
HIST_timestamp(&intvl_wait_start); \
do { \
HIST_timestamp(intvl_two_ptr); } \
while(delta_micro(intvl_one_ptr,intvl_two_ptr) < interval_usecs); \
interval_wait_microseconds += \
delta_micro(&intvl_wait_start,&intvl_two); \
temp_intvl_ptr = intvl_one_ptr; \
intvl_one_ptr = intvl_two_ptr; \
intvl_two_ptr = temp_intvl_ptr; \
interval_count = interval_burst; \
}
#endif
#endif
#define NETPERF_WAITALL 0x1
extern void get_uuid_string(char *string, size_t size);
/* a boatload of globals while I settle things out */
char *output_selection_spec = NULL;
char test_uuid[38];
double result_confid_pct = -1.0;
double loc_cpu_confid_pct = -1.0;
double rem_cpu_confid_pct = -1.0;
double interval_pct = -1.0;
int protocol;
int direction;
int remote_send_size = -1;
int remote_recv_size = -1;
int remote_send_size_req = -1;
int remote_recv_size_req = -1;
int remote_use_sendfile;
extern int loc_dirty_count;
extern int loc_clean_count;
extern int rem_dirty_count;
extern int rem_clean_count;
int remote_checksum_off;
int connection_test;
int dont_give_up = 0;
int use_fastopen = 0;
int use_write = 0;
int need_to_connect;
int need_connection;
int bytes_to_send;
double bytes_per_send;
int failed_sends;
int bytes_to_recv;
double bytes_per_recv;
int null_message_ok = 0;
int was_legacy = 0;
int legacy = 0;
int implicit_direction = 0;
int explicit_data_address = 0;
int want_defer_accept = 0;
uint64_t trans_completed = 0;
int64_t units_remaining;
uint64_t bytes_sent = 0;
uint64_t bytes_received = 0;
uint64_t local_send_calls = 0;
uint64_t local_receive_calls = 0;
uint64_t remote_bytes_sent;
uint64_t remote_bytes_received;
uint64_t remote_send_calls;
uint64_t remote_receive_calls;
double bytes_xferd;
double remote_bytes_xferd;
double remote_bytes_per_recv;
double remote_bytes_per_send;
float elapsed_time;
float local_cpu_utilization;
float local_service_demand;
float remote_cpu_utilization;
float remote_service_demand;
double thruput;
double local_send_thruput;
double local_recv_thruput;
double remote_send_thruput;
double remote_recv_thruput;
/* kludges for omni output */
double elapsed_time_double;
double local_service_demand_double;
double remote_service_demand_double;
double transaction_rate = 1.0;
double rtt_latency = -1.0;
int32_t transport_mss = -2;
int32_t local_transport_retrans = -2;
int32_t remote_transport_retrans = -2;
char *deprecated_str = "Deprecated";
int remote_interface_vendor = -2;
int remote_interface_device = -2;
int remote_interface_subvendor = -2;
int remote_interface_subdevice = -2;
int local_interface_vendor = -2;
int local_interface_device = -2;
int local_interface_subvendor = -2;
int local_interface_subdevice = -2;
int local_cpu_frequency = 0;
int remote_cpu_frequency = 0;
int local_security_type_id;
int local_security_enabled_num;
int remote_security_type_id;
int remote_security_enabled_num;
char local_cong_control[16] = "";
char remote_cong_control[16] = "";
char local_cong_control_req[16] = "";
char remote_cong_control_req[16] = "";
int receive_timeout = -1;
/* new statistics based on code diffs from Google, with raj's own
personal twist added to make them compatible with the omni
tests... 20100913 */
/* min and max "latency" */
int min_latency = -1, max_latency = -1;
/* the percentiles */
int p50_latency = -1, p90_latency = -1, p99_latency = -1;
/* mean and stddev - while the mean is reduntant with the *_RR test we
keep it because it won't be for other tests */
double mean_latency = -1.0, stddev_latency = -1.0;
/* default to zero to avoid randomizing */
int local_mask_len = 0;
int remote_mask_len = 0;
int printing_initialized = 0;
char *sd_str;
char *thruput_format_str;
char *socket_type_str;
char *protocol_str;
char *direction_str;
extern int first_burst_size;
int parallel_connections = 1;
static int socket_debug = 0;
#if defined(HAVE_SENDFILE) && (defined(__linux) || defined(__sun))
#include <sys/sendfile.h>
#endif /* HAVE_SENDFILE && (__linux || __sun) */
static int confidence_iteration;
static int local_cpu_method;
static int remote_cpu_method;
/* these will control the width of port numbers we try to use in the */
/* TCP_CRR and/or TCP_TRR tests. raj 3/95 */
static int client_port_min = 5000;
static int client_port_max = 65535;
/* different options for the sockets */
int
loc_nodelay, /* don't/do use NODELAY locally */
rem_nodelay, /* don't/do use NODELAY remotely */
loc_sndavoid, /* avoid send copies locally */
loc_rcvavoid, /* avoid recv copies locally */
rem_sndavoid, /* avoid send copies remotely */
rem_rcvavoid; /* avoid recv_copies remotely */
extern int
loc_tcpcork,
rem_tcpcork,
local_connected,
remote_connected;
enum netperf_output_type {
NETPERF_TYPE_UNKNOWN,
NETPERF_TYPE_UINT32,
NETPERF_TYPE_INT32,
NETPERF_TYPE_UINT64,
NETPERF_TYPE_INT64,
NETPERF_TYPE_CHAR,
NETPERF_TYPE_FLOAT,
NETPERF_TYPE_DOUBLE,
};
/* you should add to this in the order in which they should appear in
the default csv (everything) output */
enum netperf_output_name {
NETPERF_OUTPUT_UNKNOWN,
OUTPUT_NONE,
SOCKET_TYPE,
PROTOCOL,
DIRECTION,
ELAPSED_TIME,
THROUGHPUT,
THROUGHPUT_UNITS,
LSS_SIZE_REQ,
LSS_SIZE,
LSS_SIZE_END,
LSR_SIZE_REQ,
LSR_SIZE,
LSR_SIZE_END,
RSS_SIZE_REQ,
RSS_SIZE,
RSS_SIZE_END,
RSR_SIZE_REQ,
RSR_SIZE,
RSR_SIZE_END,
LOCAL_SEND_SIZE,
LOCAL_RECV_SIZE,
REMOTE_SEND_SIZE,
REMOTE_RECV_SIZE,
REQUEST_SIZE,
RESPONSE_SIZE,
LOCAL_CPU_UTIL,
LOCAL_CPU_PERCENT_USER,
LOCAL_CPU_PERCENT_SYSTEM,
LOCAL_CPU_PERCENT_IOWAIT,
LOCAL_CPU_PERCENT_IRQ,
LOCAL_CPU_PERCENT_SWINTR,
LOCAL_CPU_METHOD,
LOCAL_SD,
REMOTE_CPU_UTIL,
REMOTE_CPU_PERCENT_USER,
REMOTE_CPU_PERCENT_SYSTEM,
REMOTE_CPU_PERCENT_IOWAIT,
REMOTE_CPU_PERCENT_IRQ,
REMOTE_CPU_PERCENT_SWINTR,
REMOTE_CPU_METHOD,
REMOTE_SD,
SD_UNITS,
CONFIDENCE_LEVEL,
CONFIDENCE_INTERVAL,
CONFIDENCE_ITERATION,
THROUGHPUT_CONFID,
LOCAL_CPU_CONFID,
REMOTE_CPU_CONFID,
TRANSACTION_RATE,
RT_LATENCY,
BURST_SIZE,
LOCAL_TRANSPORT_RETRANS,
REMOTE_TRANSPORT_RETRANS,
TRANSPORT_MSS,
LOCAL_SEND_THROUGHPUT,
LOCAL_RECV_THROUGHPUT,
REMOTE_SEND_THROUGHPUT,
REMOTE_RECV_THROUGHPUT,
LOCAL_CPU_BIND,
LOCAL_CPU_COUNT,
LOCAL_CPU_PEAK_UTIL,
LOCAL_CPU_PEAK_ID,
LOCAL_CPU_MODEL,
LOCAL_CPU_FREQUENCY,
REMOTE_CPU_BIND,
REMOTE_CPU_COUNT,
REMOTE_CPU_PEAK_UTIL,
REMOTE_CPU_PEAK_ID,
REMOTE_CPU_MODEL,
REMOTE_CPU_FREQUENCY,
SOURCE_PORT,
SOURCE_ADDR,
SOURCE_FAMILY,
DEST_PORT,
DEST_ADDR,
DEST_FAMILY,
LOCAL_SEND_CALLS,
LOCAL_RECV_CALLS,
LOCAL_BYTES_PER_RECV,
LOCAL_BYTES_PER_SEND,
LOCAL_BYTES_SENT,
LOCAL_BYTES_RECVD,
LOCAL_BYTES_XFERD,
LOCAL_SEND_OFFSET,
LOCAL_RECV_OFFSET,
LOCAL_SEND_ALIGN,
LOCAL_RECV_ALIGN,
LOCAL_SEND_WIDTH,
LOCAL_RECV_WIDTH,
LOCAL_SEND_DIRTY_COUNT,
LOCAL_RECV_DIRTY_COUNT,
LOCAL_RECV_CLEAN_COUNT,
LOCAL_NODELAY,
LOCAL_CORK,
REMOTE_SEND_CALLS,
REMOTE_RECV_CALLS,
REMOTE_BYTES_PER_RECV,
REMOTE_BYTES_PER_SEND,
REMOTE_BYTES_SENT,
REMOTE_BYTES_RECVD,
REMOTE_BYTES_XFERD,
REMOTE_SEND_OFFSET,
REMOTE_RECV_OFFSET,
REMOTE_SEND_ALIGN,
REMOTE_RECV_ALIGN,
REMOTE_SEND_WIDTH,
REMOTE_RECV_WIDTH,
REMOTE_SEND_DIRTY_COUNT,
REMOTE_RECV_DIRTY_COUNT,
REMOTE_RECV_CLEAN_COUNT,
REMOTE_NODELAY,
REMOTE_CORK,
LOCAL_SYSNAME,
LOCAL_SYSTEM_MODEL,
LOCAL_RELEASE,
LOCAL_VERSION,
LOCAL_MACHINE,
REMOTE_SYSNAME,
REMOTE_SYSTEM_MODEL,
REMOTE_RELEASE,
REMOTE_VERSION,
REMOTE_MACHINE,
LOCAL_INTERFACE_NAME,
LOCAL_INTERFACE_VENDOR,
LOCAL_INTERFACE_DEVICE,
LOCAL_INTERFACE_SUBVENDOR,
LOCAL_INTERFACE_SUBDEVICE,
LOCAL_DRIVER_NAME,
LOCAL_DRIVER_VERSION,
LOCAL_DRIVER_FIRMWARE,
LOCAL_DRIVER_BUS,
LOCAL_INTERFACE_SLOT,
REMOTE_INTERFACE_NAME,
REMOTE_INTERFACE_VENDOR,
REMOTE_INTERFACE_DEVICE,
REMOTE_INTERFACE_SUBVENDOR,
REMOTE_INTERFACE_SUBDEVICE,
REMOTE_DRIVER_NAME,
REMOTE_DRIVER_VERSION,
REMOTE_DRIVER_FIRMWARE,
REMOTE_DRIVER_BUS,
REMOTE_INTERFACE_SLOT,
LOCAL_INTERVAL_USECS,
LOCAL_INTERVAL_BURST,
REMOTE_INTERVAL_USECS,
REMOTE_INTERVAL_BURST,
LOCAL_SECURITY_TYPE_ID,
LOCAL_SECURITY_TYPE,
LOCAL_SECURITY_ENABLED_NUM,
LOCAL_SECURITY_ENABLED,
LOCAL_SECURITY_SPECIFIC,
REMOTE_SECURITY_TYPE_ID,
REMOTE_SECURITY_TYPE,
REMOTE_SECURITY_ENABLED_NUM,
REMOTE_SECURITY_ENABLED,
REMOTE_SECURITY_SPECIFIC,
RESULT_BRAND,
UUID,
MIN_LATENCY,
MAX_LATENCY,
P50_LATENCY,
P90_LATENCY,
P99_LATENCY,
MEAN_LATENCY,
STDDEV_LATENCY,
LOCAL_SOCKET_PRIO,
REMOTE_SOCKET_PRIO,
LOCAL_SOCKET_TOS,
REMOTE_SOCKET_TOS,
LOCAL_CONG_CONTROL,
REMOTE_CONG_CONTROL,
LOCAL_FILL_FILE,
REMOTE_FILL_FILE,
COMMAND_LINE, /* COMMAND_LINE should always be "last" */
OUTPUT_END,
NETPERF_OUTPUT_MAX
};
/* flags for the output groups, lower 16 bits for remote, upper 16
bits for local */
#define OMNI_WANT_REM_IFNAME 0X00000001
#define OMNI_WANT_LOC_IFNAME 0X00010000
#define OMNI_WANT_REM_IFSLOT 0X00000002
#define OMNI_WANT_LOC_IFSLOT 0X00020000
#define OMNI_WANT_REM_IFIDS 0X00000004
#define OMNI_WANT_LOC_IFIDS 0X00040000
#define OMNI_WANT_REM_DRVINFO 0X00000008
#define OMNI_WANT_LOC_DRVINFO 0X00080000
#define OMNI_WANT_STATS 0X00100010
#define OMNI_WANT_REM_CONG 0X00000020
#define OMNI_WANT_LOC_CONG 0X00200000
unsigned int desired_output_groups = 0;
typedef struct netperf_output_elt {
enum netperf_output_name output_name; /* belt and suspenders */
int max_line_len; /* length of the longest of the "lines" */
int tot_line_len; /* total length of all lines, including spaces */
char *line[4];
char *format; /* format to apply to value */
void *display_value; /* where to find the value */
enum netperf_output_type output_type; /* what type is the value? */
int output_default; /* is it included in the default output */
unsigned int output_group; /* used to avoid some lookups */
} netperf_output_elt_t;
netperf_output_elt_t netperf_output_source[NETPERF_OUTPUT_MAX];
#define NETPERF_MAX_BLOCKS 4
/* let us simply use one, two-dimensional list, and either use or some
of the additional dimension depending on the type of output we are
doing. this should help simplify matters. raj 20110120 */
enum netperf_output_name output_list[NETPERF_MAX_BLOCKS][NETPERF_OUTPUT_MAX];
/* some things for setting the source IP address on outgoing UDP
sends. borrows liberally from
http://stackoverflow.com/questions/3062205/setting-the-source-ip-for-a-udp-socket */
int want_use_pktinfo = 0;
int use_pktinfo = 0;
int have_pktinfo = 0;
#ifdef IP_PKTINFO
struct in_pktinfo in_pktinfo;
#endif
char *direction_to_str(int direction) {
if (NETPERF_RECV_ONLY(direction)) return "Receive";
if (NETPERF_XMIT_ONLY(direction)) return "Send";
if (NETPERF_CC(direction)) return "Connection";
else if (connection_test) {
return "Connect|Send|Recv";
}
else return "Send|Recv";
}
static unsigned short
get_port_number(struct addrinfo *res)
{
switch(res->ai_family) {
case AF_INET: {
struct sockaddr_in *foo = (struct sockaddr_in *)res->ai_addr;
return(ntohs(foo->sin_port));
break;
}
#if defined(AF_INET6)
case AF_INET6: {
struct sockaddr_in6 *foo = (struct sockaddr_in6 *)res->ai_addr;
return(ntohs(foo->sin6_port));
break;
}
#endif
default:
fprintf(where,
"Unexpected Address Family %u\n",res->ai_family);
fflush(where);
exit(-1);
}
}
/* does this need to become conditional on the presence of the macros
or might we ass-u-me that we will not be compiled on something so
old as to not have what we use? raj 20090803 */
static int
is_multicast_addr(struct addrinfo *res) {
switch(res->ai_family) {
case AF_INET: {
/* IPv4 multicast runs from 224.0.0.0 to 239.255.255.255 or
0xE0000000 to 0xEFFFFFFF. Thankfully though there are macros
available to make the checks for one */
struct in_addr bar = ((struct sockaddr_in *)res->ai_addr)->sin_addr;
/* and here I thought IN_MULTICAST would operate on things in
network byte order??? raj 20100315 */
return IN_MULTICAST(ntohl(bar.s_addr));
}
#if defined(AF_INET6)
case AF_INET6: {
struct in6_addr *bar = &(((struct sockaddr_in6 *)res->ai_addr)->sin6_addr);
return IN6_IS_ADDR_MULTICAST(bar);
}
#endif
default:
fprintf(where,
"Unexpected Address Family for Multicast Check %u\n",
res->ai_family);
fflush(where);
return 0; /* or should we exit? */
}
}
static void
set_multicast_ttl(SOCKET sock) {
int optlen = sizeof(int);
/* now set/get the TTL */
if (multicast_ttl >= 0) {
if (setsockopt(sock,
IPPROTO_IP,
#if defined(IP_MULTICAST_TTL)
IP_MULTICAST_TTL,
#else
IP_TTL,
#endif
(const char *)&multicast_ttl,
sizeof(multicast_ttl)) == SOCKET_ERROR) {
fprintf(where,
"setsockopt(IP_TTL) failed errno %d\n",
errno);
}
}
if (getsockopt(sock,
IPPROTO_IP,
IP_TTL,
(char *)&multicast_ttl,
(netperf_socklen_t *)&optlen) < 0) {
fprintf(where,
"getsockopt(IP_TTL) failed errno %d\n",
errno);
multicast_ttl = -2;
}
}
/* we presume we are only called with something which is actually a
multicast address. raj 20100315 */
static void
join_multicast_addr(SOCKET sock, struct addrinfo *res) {
switch(res->ai_family) {
case AF_INET: {
struct ip_mreq mreq;
struct in_addr bar = ((struct sockaddr_in *)res->ai_addr)->sin_addr;
int optlen = sizeof(int);
int one = 1;
mreq.imr_multiaddr.s_addr=bar.s_addr;
mreq.imr_interface.s_addr=htonl(INADDR_ANY);
if (setsockopt(sock,
IPPROTO_IP,
IP_ADD_MEMBERSHIP,
(const char *)&mreq,
sizeof(mreq)) == 0) {
/* let others do the same */
if (setsockopt(sock,
SOL_SOCKET,
SO_REUSEADDR,
(const char *)&one,
sizeof(one)) == SOCKET_ERROR) {
if (debug) {
fprintf(where,
"join_multicast_addr SO_REUSADDR failed errno %d\n",
errno);
fflush(where);
}
}
/* now set/get the TTL */
if (multicast_ttl >= 0) {
if (setsockopt(sock,
IPPROTO_IP,
IP_TTL,
(const char *)&multicast_ttl,
sizeof(multicast_ttl)) == SOCKET_ERROR) {
fprintf(where,
"setsockopt(IP_TTL) failed errno %d\n",
errno);
}
}
if (getsockopt(sock,
IPPROTO_IP,
IP_TTL,
(char *)&multicast_ttl,
(netperf_socklen_t *)&optlen) == SOCKET_ERROR) {
fprintf(where,
"getsockopt(IP_TTL) failed errno %d\n",
errno);
multicast_ttl = -2;
}
}
else {
if (debug) {
fprintf(where,
"setsockopt(IP_ADD_MEMBERSHIP) failed errno %d\n",
errno);
fflush(where);
}
}
break;
}
case AF_INET6: {
fprintf(where,"I do not know how to join an IPv6 multicast group\n");
break;
}
}
return;
}
static void
extract_inet_address_and_port(struct addrinfo *res, void *addr, int len, int *port)
{
switch(res->ai_family) {
case AF_INET: {
struct sockaddr_in *foo = (struct sockaddr_in *)res->ai_addr;
*port = foo->sin_port;
memcpy(addr,&(foo->sin_addr),min(len,sizeof(foo->sin_addr)));
break;
}
#if defined(AF_INET6)
case AF_INET6: {
struct sockaddr_in6 *foo = (struct sockaddr_in6 *)res->ai_addr;
*port = foo->sin6_port;
memcpy(addr,&(foo->sin6_addr),min(len,sizeof(foo->sin6_addr)));
break;
}
#endif
default:
*port = 0xDEADBEEF;
strncpy(addr,"UNKN FAMILY",len);
}
}
void
pick_next_port_number(struct addrinfo *local_res, struct addrinfo *remote_res) {
static int myport_init = 0;
static unsigned short myport = 0;
if (0 == myport_init) {
/* pick a nice random spot between client_port_min and
client_port_max for our initial port number, but only for a
connection oriented test. otherwise, we will want to set myport
to a specific port provided by the user if they have so provided
a specific port :) raj 2008-01-08 */
srand(getpid());
if (client_port_max - client_port_min) {
myport = client_port_min +
(rand() % (client_port_max - client_port_min));
}
else {
myport = (unsigned short)client_port_min;
}
/* there will be a ++ before the first call to bind, so subtract one */
myport--;
myport_init = 1;
}
/* newport: */
/* pick a new port number */
myport++;
/* check to see if we are using the port number on which the
server is sitting _before_ we check against the boundaries lest
the server sits at the upper boundary. if this happens to be a
loopback test, trying to use the same portnumber would lead to
unsatisfying results and should be avoided. if this isn't a
loopback test, avoiding using the same port number doesn't
seriously affect anything anyway */
if (myport == get_port_number(remote_res)) myport++;
/* wrap the port number when we reach the upper bound. for
students of networking history, some ancient stacks (1980's and
early 1990's perhaps) mistakenly treated these port numbers as
signed 16 bit quantities. we make no effort here to support
such stacks. raj 2008-01-08 */
if (myport >= client_port_max) {
myport = (unsigned short)client_port_min;
}
/* set up the data socket */
set_port_number(local_res, (unsigned short)myport);
}
/* at some point this should become a table lookup... raj 20090813 */
char *
netperf_output_enum_to_str(enum netperf_output_name output_name)
{
switch (output_name) {
case OUTPUT_NONE:
return "OUTPUT_NONE";
case COMMAND_LINE:
return "COMMAND_LINE";
case UUID:
return "UUID";
case RESULT_BRAND:
return "RESULT_BRAND";
case SOCKET_TYPE:
return "SOCKET_TYPE";
case DIRECTION:
return "DIRECTION";
case PROTOCOL:
return "PROTOCOL";
case ELAPSED_TIME:
return "ELAPSED_TIME";
case SOURCE_PORT:
return "SOURCE_PORT";
case SOURCE_ADDR:
return "SOURCE_ADDR";
case SOURCE_FAMILY:
return "SOURCE_FAMILY";
case DEST_PORT:
return "DEST_PORT";
case DEST_ADDR:
return "DEST_ADDR";
case DEST_FAMILY:
return "DEST_FAMILY";
case THROUGHPUT:
return "THROUGHPUT";
case LOCAL_SEND_THROUGHPUT:
return "LOCAL_SEND_THROUGHPUT";
case LOCAL_RECV_THROUGHPUT:
return "LOCAL_RECV_THROUGHPUT";
case REMOTE_SEND_THROUGHPUT:
return "REMOTE_SEND_THROUGHPUT";
case REMOTE_RECV_THROUGHPUT:
return "REMOTE_RECV_THROUGHPUT";
case THROUGHPUT_UNITS:
return "THROUGHPUT_UNITS";
case CONFIDENCE_LEVEL:
return "CONFIDENCE_LEVEL";
case CONFIDENCE_INTERVAL:
return "CONFIDENCE_INTERVAL";
case CONFIDENCE_ITERATION:
return "CONFIDENCE_ITERATION";
case THROUGHPUT_CONFID:
return "THROUGHPUT_CONFID";
case LOCAL_CPU_CONFID:
return "LOCAL_CPU_CONFID";
case REMOTE_CPU_CONFID:
return "REMOTE_CPU_CONFID";
case RT_LATENCY:
return "RT_LATENCY";
case TRANSACTION_RATE:
return "TRANSACTION_RATE";
case BURST_SIZE:
return "BURST_SIZE";
case LOCAL_TRANSPORT_RETRANS:
return "LOCAL_TRANSPORT_RETRANS";
case REMOTE_TRANSPORT_RETRANS:
return "REMOTE_TRANSPORT_RETRANS";
case TRANSPORT_MSS:
return "TRANSPORT_MSS";
case REQUEST_SIZE:
return "REQUEST_SIZE";
case RESPONSE_SIZE:
return "RESPONSE_SIZE";
case LSS_SIZE_REQ:
return "LSS_SIZE_REQ";
case LSS_SIZE:
return "LSS_SIZE";
case LSS_SIZE_END:
return "LSS_SIZE_END";
case LSR_SIZE_REQ:
return "LSR_SIZE_REQ";
case LSR_SIZE:
return "LSR_SIZE";
case LSR_SIZE_END:
return "LSR_SIZE_END";
case LOCAL_SEND_SIZE:
return "LOCAL_SEND_SIZE";
case LOCAL_RECV_SIZE:
return "LOCAL_RECV_SIZE";
case LOCAL_SEND_CALLS:
return "LOCAL_SEND_CALLS";
case LOCAL_RECV_CALLS:
return "LOCAL_RECV_CALLS";
case LOCAL_BYTES_PER_RECV:
return "LOCAL_BYTES_PER_RECV";
case LOCAL_BYTES_PER_SEND:
return "LOCAL_BYTES_PER_SEND";
case LOCAL_BYTES_SENT:
return "LOCAL_BYTES_SENT";
case LOCAL_BYTES_RECVD:
return "LOCAL_BYTES_RECVD";
case LOCAL_BYTES_XFERD:
return "LOCAL_BYTES_XFERD";
case LOCAL_SEND_OFFSET:
return "LOCAL_SEND_OFFSET";
case LOCAL_RECV_OFFSET:
return "LOCAL_RECV_OFFSET";
case LOCAL_RECV_ALIGN:
return "LOCAL_RECV_ALIGN";
case LOCAL_SEND_ALIGN:
return "LOCAL_SEND_ALIGN";
case LOCAL_SEND_WIDTH:
return "LOCAL_SEND_WIDTH";
case LOCAL_RECV_WIDTH:
return "LOCAL_RECV_WIDTH";
case LOCAL_SEND_DIRTY_COUNT:
return "LOCAL_SEND_DIRTY_COUNT";
case LOCAL_RECV_DIRTY_COUNT:
return "LOCAL_RECV_DIRTY_COUNT";
case LOCAL_RECV_CLEAN_COUNT:
return "LOCAL_RECV_CLEAN_COUNT";
case LOCAL_CPU_UTIL:
return "LOCAL_CPU_UTIL";
case LOCAL_CPU_PERCENT_USER:
return "LOCAL_CPU_PERCENT_USER";
case LOCAL_CPU_PERCENT_SYSTEM:
return "LOCAL_CPU_PERCENT_SYSTEM";
case LOCAL_CPU_PERCENT_IOWAIT:
return "LOCAL_CPU_PERCENT_IOWAIT";
case LOCAL_CPU_PERCENT_IRQ:
return "LOCAL_CPU_PERCENT_IRQ";
case LOCAL_CPU_PERCENT_SWINTR:
return "LOCAL_CPU_PERCENT_SWINTR";
case LOCAL_CPU_BIND:
return "LOCAL_CPU_BIND";
case LOCAL_SD:
return "LOCAL_SD";
case SD_UNITS:
return "SD_UNITS";
case LOCAL_CPU_METHOD:
return "LOCAL_CPU_METHOD";
case LOCAL_CPU_COUNT:
return "LOCAL_CPU_COUNT";
case LOCAL_CPU_PEAK_UTIL:
return "LOCAL_CPU_PEAK_UTIL";
case LOCAL_CPU_PEAK_ID:
return "LOCAL_CPU_PEAK_ID";
case LOCAL_NODELAY:
return "LOCAL_NODELAY";
case LOCAL_CORK:
return "LOCAL_CORK";
case RSS_SIZE_REQ:
return "RSS_SIZE_REQ";
case RSS_SIZE:
return "RSS_SIZE";
case RSS_SIZE_END:
return "RSS_SIZE_END";
case RSR_SIZE_REQ:
return "RSR_SIZE_REQ";
case RSR_SIZE:
return "RSR_SIZE";
case RSR_SIZE_END:
return "RSR_SIZE_END";
case REMOTE_SEND_SIZE:
return "REMOTE_SEND_SIZE";
case REMOTE_RECV_SIZE:
return "REMOTE_RECV_SIZE";
case REMOTE_SEND_CALLS:
return "REMOTE_SEND_CALLS";
case REMOTE_RECV_CALLS:
return "REMOTE_RECV_CALLS";
case REMOTE_BYTES_PER_RECV:
return "REMOTE_BYTES_PER_RECV";
case REMOTE_BYTES_PER_SEND:
return "REMOTE_BYTES_PER_SEND";
case REMOTE_BYTES_SENT:
return "REMOTE_BYTES_SENT";
case REMOTE_BYTES_RECVD:
return "REMOTE_BYTES_RECVD";
case REMOTE_BYTES_XFERD:
return "REMOTE_BYTES_XFERD";
case REMOTE_SEND_OFFSET:
return "REMOTE_SEND_OFFSET";
case REMOTE_RECV_OFFSET:
return "REMOTE_RECV_OFFSET";
case REMOTE_RECV_ALIGN:
return "REMOTE_RECV_ALIGN";
case REMOTE_SEND_ALIGN:
return "REMOTE_SEND_ALIGN";
case REMOTE_SEND_WIDTH:
return "REMOTE_SEND_WIDTH";
case REMOTE_RECV_WIDTH:
return "REMOTE_RECV_WIDTH";
case REMOTE_SEND_DIRTY_COUNT:
return "REMOTE_SEND_DIRTY_COUNT";
case REMOTE_RECV_DIRTY_COUNT:
return "REMOTE_RECV_DIRTY_COUNT";
case REMOTE_RECV_CLEAN_COUNT:
return "REMOTE_RECV_CLEAN_COUNT";
case REMOTE_CPU_UTIL:
return "REMOTE_CPU_UTIL";
case REMOTE_CPU_PERCENT_USER:
return "REMOTE_CPU_PERCENT_USER";
case REMOTE_CPU_PERCENT_SYSTEM:
return "REMOTE_CPU_PERCENT_SYSTEM";
case REMOTE_CPU_PERCENT_IOWAIT:
return "REMOTE_CPU_PERCENT_IOWAIT";
case REMOTE_CPU_PERCENT_IRQ:
return "REMOTE_CPU_PERCENT_IRQ";
case REMOTE_CPU_PERCENT_SWINTR:
return "REMOTE_CPU_PERCENT_SWINTR";
case REMOTE_CPU_BIND:
return "REMOTE_CPU_BIND";
case REMOTE_SD:
return "REMOTE_SD";
case REMOTE_CPU_METHOD:
return "REMOTE_CPU_METHOD";
case REMOTE_CPU_COUNT:
return "REMOTE_CPU_COUNT";
case REMOTE_CPU_PEAK_UTIL:
return "REMOTE_CPU_PEAK_UTIL";
case REMOTE_CPU_PEAK_ID:
return "REMOTE_CPU_PEAK_ID";
case REMOTE_NODELAY:
return "REMOTE_NODELAY";
case REMOTE_CORK:
return "REMOTE_CORK";
case LOCAL_INTERFACE_SLOT:
return "LOCAL_INTERFACE_SLOT";
case REMOTE_INTERFACE_SLOT:
return "REMOTE_INTERFACE_SLOT";
case REMOTE_INTERFACE_SUBDEVICE:
return "REMOTE_INTERFACE_SUBDEVICE";
case REMOTE_INTERFACE_SUBVENDOR:
return "REMOTE_INTERFACE_SUBVENDOR";
case REMOTE_INTERFACE_DEVICE:
return "REMOTE_INTERFACE_DEVICE";
case REMOTE_INTERFACE_VENDOR:
return "REMOTE_INTERFACE_VENDOR";
case LOCAL_INTERFACE_SUBDEVICE:
return "LOCAL_INTERFACE_SUBDEVICE";
case LOCAL_INTERFACE_SUBVENDOR:
return "LOCAL_INTERFACE_SUBVENDOR";
case LOCAL_INTERFACE_DEVICE:
return "LOCAL_INTERFACE_DEVICE";
case LOCAL_INTERFACE_VENDOR:
return "LOCAL_INTERFACE_VENDOR";
case LOCAL_INTERFACE_NAME:
return "LOCAL_INTERFACE_NAME";
case REMOTE_INTERFACE_NAME:
return "REMOTE_INTERFACE_NAME";
case REMOTE_DRIVER_NAME:
return "REMOTE_DRIVER_NAME";
case REMOTE_DRIVER_VERSION:
return "REMOTE_DRIVER_VERSION";
case REMOTE_DRIVER_FIRMWARE:
return "REMOTE_DRIVER_FIRMWARE";
case REMOTE_DRIVER_BUS:
return "REMOTE_DRIVER_BUS";
case LOCAL_DRIVER_NAME:
return "LOCAL_DRIVER_NAME";
case LOCAL_DRIVER_VERSION:
return "LOCAL_DRIVER_VERSION";
case LOCAL_DRIVER_FIRMWARE:
return "LOCAL_DRIVER_FIRMWARE";
case LOCAL_INTERVAL_USECS:
return "LOCAL_INTERVAL_USECS";
case LOCAL_INTERVAL_BURST:
return "LOCAL_INTERVAL_BURST";
case REMOTE_INTERVAL_USECS:
return "REMOTE_INTERVAL_USECS";
case REMOTE_INTERVAL_BURST:
return "REMOTE_INTERVAL_BURST";
case LOCAL_SECURITY_TYPE_ID:
return "LOCAL_SECURITY_TYPE_ID";
case LOCAL_SECURITY_ENABLED_NUM:
return "LOCAL_SECURITY_ENABLED_NUM";
case LOCAL_SECURITY_TYPE:
return "LOCAL_SECURITY_TYPE";
case LOCAL_SECURITY_ENABLED:
return "LOCAL_SECURITY_ENABLED";
case LOCAL_SECURITY_SPECIFIC:
return "LOCAL_SECURITY_SPECIFIC";
case REMOTE_SECURITY_TYPE_ID:
return "REMOTE_SECURITY_TYPE_ID";
case REMOTE_SECURITY_ENABLED_NUM:
return "REMOTE_SECURITY_ENABLED_NUM";
case REMOTE_SECURITY_TYPE:
return "REMOTE_SECURITY_TYPE";
case REMOTE_SECURITY_ENABLED:
return "REMOTE_SECURITY_ENABLED";
case REMOTE_SECURITY_SPECIFIC:
return "REMOTE_SECURITY_SPECIFIC";
case LOCAL_DRIVER_BUS:
return "LOCAL_DRIVER_BUS";
case REMOTE_SYSNAME:
return "REMOTE_SYSNAME";
case REMOTE_MACHINE:
return "REMOTE_MACHINE";
case REMOTE_VERSION:
return "REMOTE_VERSION";
case REMOTE_RELEASE:
return "REMOTE_RELEASE";
case LOCAL_SYSNAME:
return "LOCAL_SYSNAME";
case LOCAL_MACHINE:
return "LOCAL_MACHINE";
case LOCAL_VERSION:
return "LOCAL_VERSION";
case LOCAL_RELEASE:
return "LOCAL_RELEASE";
case REMOTE_CPU_MODEL:
return "REMOTE_CPU_MODEL";
case REMOTE_CPU_FREQUENCY:
return "REMOTE_CPU_FREQUENCY";
case REMOTE_SYSTEM_MODEL:
return "REMOTE_SYSTEM_MODEL";
case LOCAL_CPU_MODEL:
return "LOCAL_CPU_MODEL";
case LOCAL_CPU_FREQUENCY:
return "LOCAL_CPU_FREQUENCY";
case LOCAL_SYSTEM_MODEL:
return "LOCAL_SYSTEM_MODEL";
case MIN_LATENCY:
return "MIN_LATENCY";
case MAX_LATENCY:
return "MAX_LATENCY";
case P50_LATENCY:
return "P50_LATENCY";
case P90_LATENCY:
return "P90_LATENCY";
case P99_LATENCY:
return "P99_LATENCY";
case MEAN_LATENCY:
return "MEAN_LATENCY";
case STDDEV_LATENCY:
return "STDDEV_LATENCY";
case LOCAL_SOCKET_PRIO:
return "LOCAL_SOCKET_PRIO";
case REMOTE_SOCKET_PRIO:
return "REMOTE_SOCKET_PRIO";
case LOCAL_SOCKET_TOS:
return "LOCAL_SOCKET_TOS";
case REMOTE_SOCKET_TOS:
return "REMOTE_SOCKET_TOS";
case LOCAL_CONG_CONTROL:
return "LOCAL_CONG_CONTROL";
case REMOTE_CONG_CONTROL:
return "REMOTE_CONG_CONTROL";
case LOCAL_FILL_FILE:
return "LOCAL_FILL_FILE";
case REMOTE_FILL_FILE:
return "REMOTE_FILL_FILE";
case OUTPUT_END:
return "OUTPUT_END";
default:
return "!UNKNOWN OUTPUT SELECTOR!";
}
}
void
print_netperf_output_entry(FILE *where, enum netperf_output_name what)
{
}
void print_omni_init_list();
void
dump_netperf_output_list(FILE *where) {
int i,j;
for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
fprintf(where,"Output Block %d\n",i + 1);
for (j = 0; j < NETPERF_OUTPUT_MAX; j++) {
fprintf(where,"%s ",netperf_output_enum_to_str(output_list[i][j]));
}
fprintf(where,"\n");
}
fflush(where);
}
void
dump_netperf_output_choices(FILE *where, int csv) {
int i;
print_omni_init_list();
for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++){
if (OUTPUT_NONE != i) {
fprintf(where,"%c",(csv) ? ',' : '\n');
}
fprintf(where,
"%s",
netperf_output_enum_to_str(netperf_output_source[i].output_name));
}
fprintf(where,"\n");
fflush(where);
}
void
dump_netperf_output_source(FILE *where)
{
int i;
/* belts and suspenders everyone... */
for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++) {
fprintf(where,
"Output Name: %s\n"
"\tmax_line_len %d tot_line_len %d display_value %p\n"
"\tline[0]: |%s|\n"
"\tline[1]: |%s|\n"
"\tline[2]: |%s|\n"
"\tline[3]: |%s|\n"
"\tformat: |%s|\n",
netperf_output_enum_to_str(netperf_output_source[i].output_name),
netperf_output_source[i].max_line_len,
netperf_output_source[i].tot_line_len,
netperf_output_source[i].display_value,
(netperf_output_source[i].line[0] == NULL) ? "" :
netperf_output_source[i].line[0],
(netperf_output_source[i].line[1] == NULL) ? "" :
netperf_output_source[i].line[1],
(netperf_output_source[i].line[2] == NULL) ? "" :
netperf_output_source[i].line[2],
(netperf_output_source[i].line[3] == NULL) ? "" :
netperf_output_source[i].line[3],
(netperf_output_source[i].format == NULL) ? "" :
netperf_output_source[i].format);
}
fflush(where);
}
#define MY_MAX(a,b) ((a > b) ? a : b)
#define NETPERF_LINE_MAX(x) \
MY_MAX(MY_MAX(MY_MAX(strlen(netperf_output_source[x].line[0]),\
strlen(netperf_output_source[x].line[1])),\
strlen(netperf_output_source[x].line[2])),\
strlen(netperf_output_source[x].line[3]))
#define NETPERF_LINE_TOT(x) \
strlen(netperf_output_source[x].line[0]) +\
strlen(netperf_output_source[x].line[1]) +\
strlen(netperf_output_source[x].line[2]) +\
strlen(netperf_output_source[x].line[3]) + 4
enum netperf_output_name
match_string_to_output_mnenomic(char *candidate) {
enum netperf_output_name name;
for (name = OUTPUT_NONE; name < NETPERF_OUTPUT_MAX; name++) {
if(!strcasecmp(candidate,netperf_output_enum_to_str(name)))
return name;
}
return NETPERF_OUTPUT_UNKNOWN;
}
enum netperf_output_name
match_string_to_output(char *candidate)
{
char *h1,*temp;
enum netperf_output_name name;
int k,len;
/* at some point we may need/want to worry about leading and
trailing spaces, but for now we will leave that onus on the
user. */
for (name = OUTPUT_NONE; name < NETPERF_OUTPUT_MAX; name++) {
/* try for a match based on the nmemonic/enum */
if (!strcasecmp(candidate,netperf_output_enum_to_str(name)))
return name;
/* try for a match on the actual header text */
temp = malloc(NETPERF_LINE_TOT(name));
h1 = temp;
if (h1 != NULL) {
for (k = 0; ((k < 4) &&
(NULL != netperf_output_source[name].line[k]) &&
(strcmp("",netperf_output_source[name].line[k]))); k++) {
len = sprintf(h1,
"%s",
netperf_output_source[name].line[k]);
*(h1 + len) = ' ';
/* now move to the next starting column. for csv we aren't worried
about alignment between the header and the value lines */
h1 += len + 1;
}
/* this time we want null termination please */
*(h1 - 1) = 0;
if (!strcasecmp(candidate,temp)) {
free(temp);
return name;
}
else
free(temp);
}
}
/* if we get here it means there was no match */
return OUTPUT_NONE;
}
void
set_output_list_all() {
int i, j; /* line, column */
enum netperf_output_name k;
/* Line One SOCKET_TYPE to RESPONSE_SIZE */
i = 0;
j = 0;
for (k = SOCKET_TYPE; k <= RESPONSE_SIZE; k++) {
output_list[i][j++] = k;
desired_output_groups |= netperf_output_source[k].output_group;
}
/* Line Two LOCAL_CPU_UTIL to TRANSPORT_MSS */
i = 1;
j = 0;
for (k = LOCAL_CPU_UTIL; k <= TRANSPORT_MSS; k++) {
output_list[i][j++] = k;
desired_output_groups |= netperf_output_source[k].output_group;
}
/* Line Three LOCAL_SEND_THROUGHPUT throught REMOTE_CORK */
i = 2;
j = 0;
for (k = LOCAL_SEND_THROUGHPUT; k <= REMOTE_CORK; k++) {
output_list[i][j++] = k;
desired_output_groups |= netperf_output_source[k].output_group;
}
/* Line Four LOCAL_SYSNAME through COMMAND_LINE */
i = 3;
j = 0;
for (k = LOCAL_SYSNAME; k <= COMMAND_LINE; k++) {
output_list[i][j++] = k;
desired_output_groups |= netperf_output_source[k].output_group;
}
}
void
parse_output_selection_file(char *selection_file) {
FILE *selections;
char name[81]; /* best be more than enough */
int namepos;
int c;
int j;
int line,column;
selections = fopen(selection_file,"r");
if (!selections) {
fprintf(where,
"Could not open output selection file '%s' errno %d\n",
selection_file,
errno);
fflush(where);
exit(-1);
}
line = 0;
column = 1;
namepos = 0;
name[0] = 0;
name[80] = 0;
j = 0;
while (((c = fgetc(selections)) != EOF) && (line < 4)) {
if (namepos == 80) {
/* too long */
fprintf(where,
"Output selection starting column %d on line %d is too long\n",
line + 1,
column);
fflush(where);
exit(-1);
}
if (c == ',') {
/* time to check for a match, but only if we won't overflow the
current row of the array */
if (j == NETPERF_OUTPUT_MAX) {
fprintf(where,"Too many output selectors on line %d\n",line);
fflush(where);
exit(-1);
}
name[namepos] = 0;
output_list[line][j++] = match_string_to_output(name);
namepos = 0;
}
else if (c == '\n') {
/* move to the next line after checking for a match */
name[namepos] = 0;
output_list[line++][j++] = match_string_to_output(name);
namepos = 0;
j = 0;
}
else if (isprint(c)) {
name[namepos++] = (char)c;
}
column++;
}
/* ok, do we need/want to do anything here? at present we will
silently ignore the rest of the file if we exit the loop on line
count */
if ((c == EOF) && (namepos > 0)) {
name[namepos] = 0;
output_list[line][j] = match_string_to_output(name);
}
}
void
parse_output_selection_line(int line, char *list) {
char *token;
int j;
enum netperf_output_name name;
/* belt and suspenders */
if (line < 0) {
fprintf(where,
"parse_output_selection_line called with negative line number %d\n",line);
fflush(where);
exit(-1);
}
/* silently ignore extra lines and only warn if debug is set */
if (line >= NETPERF_MAX_BLOCKS) {
if (debug) {
fprintf(where,
"There can be no more than %d output selection lines."
" Ignoring output selection line %d |%s|\n",
NETPERF_MAX_BLOCKS,
line + 1,
list);
fflush(where);
}
return;
}
j=0;
token = strtok(list," ,");
while ((token) && (j < NETPERF_OUTPUT_MAX)) {
name = match_string_to_output_mnenomic(token);
if ((name == NETPERF_OUTPUT_UNKNOWN) && (debug)) {
fprintf(where,"Ignoring unknown output selector %d |%s| on line %d\n",
j + 1,
token,
line +1);
fflush(where);
}
else {
output_list[line][j] = name;
desired_output_groups |= netperf_output_source[name].output_group;
j++;
}
token = strtok(NULL," ,");
}
if ((token) && (debug)) {
fprintf(where,
"There can be no more than %d output selectors per line. "
"Ignoring remaining selectors on line %d\n",
NETPERF_OUTPUT_MAX,line +1);
fflush(where);
}
}
void
parse_output_selection_direct(char *output_selection) {
char *source,*line,*remainder,*temp;
char *f1, *f2, *f3;
int i,len,done;
len = strlen(output_selection);
source = strdup(output_selection);
line = (char *) malloc(len+1);
remainder = (char *) malloc(len+1);
if ((NULL == source) ||
(NULL == line) ||
(NULL == remainder)) {
fprintf(where,"Unable to malloc memory for output selection parsing\n");
fflush(where);
exit(-1);
}
f1 = source;
f2 = line;
f3 = remainder;
i = 0;
done = 0;
do {
break_args_explicit_sep(source,';',line,remainder);
if (line[0]) {
parse_output_selection_line(i,line);
}
if (remainder[0]) {
temp = source;
source = remainder;
remainder = temp;
i++;
/*
if (i == NETPERF_MAX_BLOCKS) {
fprintf(where,
"Too many output blocks requested, maximum is %d\n",
NETPERF_MAX_BLOCKS);
fflush(where);
exit(-1);
}
*/
continue;
}
else {
done = 1;
}
} while (!done);
free(f1);
free(f2);
free(f3);
}
/* building blocks for output selection */
#define NETPERF_TPUT "ELAPSED_TIME,THROUGHPUT,THROUGHPUT_UNITS"
#define NETPERF_OUTPUT_STREAM "LSS_SIZE_END,RSR_SIZE_END,LOCAL_SEND_SIZE"
#define NETPERF_OUTPUT_MAERTS "RSS_SIZE_END,LSR_SIZE_END,REMOTE_SEND_SIZE"
#define NETPERF_CPU "LOCAL_CPU_UTIL,LOCAL_CPU_PERCENT_USER,LOCAL_CPU_PERCENT_SYSTEM,LOCAL_CPU_PERCENT_IOWAIT,LOCAL_CPU_PERCENT_IRQ,LOCAL_CPU_PERCENT_SWINTR,LOCAL_CPU_METHOD,REMOTE_CPU_UTIL,REMOTE_CPU_PERCENT_USER,REMOTE_CPU_PERCENT_SYSTEM,REMOTE_CPU_PERCENT_IOWAIT,REMOTE_CPU_PERCENT_IRQ,REMOTE_CPU_PERCENT_SWINTR,REMOTE_CPU_METHOD,LOCAL_SD,REMOTE_SD,SD_UNITS"
#define NETPERF_RR "LSS_SIZE_END,LSR_SIZE_END,RSR_SIZE_END,RSS_SIZE_END,REQUEST_SIZE,RESPONSE_SIZE"
void
set_output_list_by_test() {
char *stream_no_cpu = NETPERF_OUTPUT_STREAM "," NETPERF_TPUT;
char *stream_cpu = NETPERF_OUTPUT_STREAM "," NETPERF_TPUT "," NETPERF_CPU;
char *maerts_no_cpu = NETPERF_OUTPUT_MAERTS "," NETPERF_TPUT;
char *maerts_cpu = NETPERF_OUTPUT_MAERTS "," NETPERF_TPUT "," NETPERF_CPU;
char *rr_no_cpu = NETPERF_RR "," NETPERF_TPUT;
char *rr_cpu = NETPERF_RR "," NETPERF_TPUT "," NETPERF_CPU;
if (debug) {
fprintf(where,"%s setting the output list by test\n",
__FUNCTION__);
fflush(where);
}
if (NETPERF_XMIT_ONLY(direction)) {
if (!(local_cpu_usage || remote_cpu_usage))
parse_output_selection_direct(stream_no_cpu);
else
parse_output_selection_direct(stream_cpu);
}
else if (NETPERF_RECV_ONLY(direction)) {
if (!(local_cpu_usage || remote_cpu_usage))
parse_output_selection_direct(maerts_no_cpu);
else
parse_output_selection_direct(maerts_cpu);
}
else if (NETPERF_CC(direction)) {
if (!(local_cpu_usage || remote_cpu_usage))
parse_output_selection_direct(rr_no_cpu);
else
parse_output_selection_direct(rr_cpu);
}
else if (NETPERF_IS_RR(direction)) {
if (!(local_cpu_usage || remote_cpu_usage))
parse_output_selection_direct(rr_no_cpu);
else
parse_output_selection_direct(rr_cpu);
}
else {
/* no idea */
if (debug) {
fprintf(where,"Cannot determine default test output, using mins\n");
fflush(where);
}
parse_output_selection_direct(NETPERF_TPUT "," NETPERF_CPU);
}
}
void
parse_output_selection(char *output_selection) {
if (debug) {
fprintf(where,"%s is parsing the output selection '%s'\n",
__FUNCTION__,
output_selection);
fflush(where);
}
/* is it the magic keyword? */
if (strcasecmp(output_selection,"all") == 0) {
set_output_list_all();
}
/* do not forget the case when the output_selection is a single
mnemonic without any separators... */
else if (strchr(output_selection,',') ||
strchr(output_selection,';') ||
(match_string_to_output_mnenomic(output_selection) !=
NETPERF_OUTPUT_UNKNOWN)) {
parse_output_selection_direct(output_selection);
}
else {
parse_output_selection_file(output_selection);
}
if (debug > 2) {
dump_netperf_output_list(stderr);
}
return;
}
static void
set_output_elt(enum netperf_output_name name,
char *line0, char *line1, char *line2, char *line3,
char *format,
void *value,
unsigned int out_default,
unsigned int group,
enum netperf_output_type type) {
netperf_output_source[name].output_name = name;
netperf_output_source[name].line[0] = line0;
netperf_output_source[name].line[1] = line1;
netperf_output_source[name].line[2] = line2;
netperf_output_source[name].line[3] = line3;
netperf_output_source[name].format = format;
netperf_output_source[name].display_value = value;
netperf_output_source[name].output_default = out_default;
netperf_output_source[name].output_group = group;
netperf_output_source[name].max_line_len = NETPERF_LINE_MAX(name);
netperf_output_source[name].tot_line_len = NETPERF_LINE_TOT(name);
netperf_output_source[name].output_type = type;
}
void
print_omni_init_list() {
int i;
if (debug) {
fprintf(where,"%s called\n",
__FUNCTION__);
}
/* belts and suspenders everyone... */
for (i = NETPERF_OUTPUT_UNKNOWN; i < NETPERF_OUTPUT_MAX; i++) {
netperf_output_source[i].output_name = i;
netperf_output_source[i].max_line_len = 0;
netperf_output_source[i].tot_line_len = 0;
netperf_output_source[i].line[0] = "";
netperf_output_source[i].line[1] = "";
netperf_output_source[i].line[2] = "";
netperf_output_source[i].line[3] = "";
netperf_output_source[i].format = "";
netperf_output_source[i].display_value = NULL;
netperf_output_source[i].output_default = 1;
netperf_output_source[i].output_group = 0;
netperf_output_source[i].output_type = NETPERF_TYPE_UNKNOWN;
}
set_output_elt(OUTPUT_NONE, " ", "", "", "", "%s", &" ",1, 0,
NETPERF_TYPE_CHAR);
set_output_elt(COMMAND_LINE, "Command","Line","","","\"%s\"",
command_line,1, 0, NETPERF_TYPE_CHAR);
set_output_elt(UUID, "Test", "UUID", "", "", "%s", test_uuid, 1, 0,
NETPERF_TYPE_CHAR);
set_output_elt(RESULT_BRAND, "Result", "Tag", "", "", "\"%s\"",
result_brand, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(SOCKET_TYPE, "Socket", "Type", "", "", "%s",
socket_type_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(DIRECTION, "Direction", "", "", "", "%s",
direction_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(PROTOCOL, "Protocol", "", "", "", "%s",
protocol_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(ELAPSED_TIME, "Elapsed", "Time", "(sec)", "", "%.2f",
&elapsed_time_double, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(SOURCE_PORT, "Source", "Port", "", "", "%s",
local_data_port, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(SOURCE_ADDR, "Source", "Address", "", "", "%s",
local_data_address, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(SOURCE_FAMILY, "Source", "Family", "", "", "%d",
&local_data_family, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(DEST_PORT, "Destination", "Port", "", "", "%s",
remote_data_port, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(DEST_ADDR, "Destination", "Address", "", "", "%s",
remote_data_address, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(DEST_FAMILY, "Destination", "Family", "", "", "%d",
&remote_data_family, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(THROUGHPUT, "Throughput", "", "", "", "%.2f",
&thruput, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_SEND_THROUGHPUT, "Local", "Send", "Throughput", "",
"%.2f", &local_send_thruput, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_RECV_THROUGHPUT, "Local", "Recv", "Throughput", "",
"%.2f", &local_recv_thruput, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_SEND_THROUGHPUT, "Remote", "Send", "Throughput", "",
"%.2f", &remote_send_thruput, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_RECV_THROUGHPUT, "Remote", "Recv", "Throughput", "",
"%.2f", &remote_recv_thruput, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(THROUGHPUT_UNITS, "Throughput", "Units", "", "", "%s/s",
thruput_format_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(CONFIDENCE_LEVEL, "Confidence", "Level", "Percent", "", "%d",
&confidence_level, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(CONFIDENCE_INTERVAL, "Confidence", "Width", "Target", "",
"%f", &interval_pct, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(CONFIDENCE_ITERATION, "Confidence", "Iterations", "Run", "",
"%d", &confidence_iteration, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(THROUGHPUT_CONFID, "Throughput", "Confidence", "Width (%)",
"", "%.3f", &result_confid_pct, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_CPU_CONFID, "Local", "CPU", "Confidence", "Width (%)",
"%.3f", &loc_cpu_confid_pct, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_CPU_CONFID, "Remote", "CPU", "Confidence", "Width (%)",
"%.3f", &rem_cpu_confid_pct, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(RT_LATENCY, "Round", "Trip", "Latency", "usec/tran", "%.3f",
&rtt_latency, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(TRANSACTION_RATE, "Transaction", "Rate", "Tran/s", "", "%.3f",
&transaction_rate, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(TRANSPORT_MSS, "Transport", "MSS", "bytes", "", "%d",
&transport_mss, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_TRANSPORT_RETRANS, "Local", "Transport",
"Retransmissions", "", "%d", &local_transport_retrans, 1, 0,
NETPERF_TYPE_INT32);
set_output_elt(REMOTE_TRANSPORT_RETRANS, "Remote", "Transport",
"Retransmissions", "", "%d", &remote_transport_retrans, 1, 0,
NETPERF_TYPE_INT32);
set_output_elt(REQUEST_SIZE, "Request", "Size", "Bytes", "", "%d",
&req_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RESPONSE_SIZE, "Response", "Size", "Bytes", "", "%d",
&rsp_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(BURST_SIZE, "Initial", "Burst", "Requests", "", "%d",
&first_burst_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LSS_SIZE_REQ, "Local", "Send Socket", "Size", "Requested",
"%d", &lss_size_req, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LSS_SIZE, "Local", "Send Socket", "Size", "Initial", "%d",
&lss_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LSS_SIZE_END, "Local", "Send Socket", "Size", "Final", "%d",
&lss_size_end, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LSR_SIZE_REQ, "Local", "Recv Socket", "Size", "Requested",
"%d", &lsr_size_req, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LSR_SIZE, "Local", "Recv Socket", "Size", "Initial", "%d",
&lsr_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LSR_SIZE_END, "Local", "Recv Socket", "Size", "Final", "%d",
&lsr_size_end, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SEND_SIZE, "Local", "Send", "Size", "", "%d",
&send_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_RECV_SIZE, "Local", "Recv", "Size", "", "%d",
&recv_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SEND_CALLS, "Local", "Send", "Calls", "", "%"PRIu64,
&local_send_calls, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(LOCAL_RECV_CALLS, "Local", "Recv", "Calls", "", "%"PRIu64,
&local_receive_calls, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(LOCAL_BYTES_PER_RECV, "Local", "Bytes", "Per", "Recv", "%.2f",
&bytes_per_recv, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_BYTES_PER_SEND, "Local", "Bytes", "Per", "Send", "%.2f",
&bytes_per_send, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_BYTES_RECVD, "Local", "Bytes", "Received", "", "%"PRIu64,
&bytes_received, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(LOCAL_BYTES_SENT, "Local", "Bytes", "Sent", "", "%"PRIu64,
&bytes_sent, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(LOCAL_BYTES_XFERD, "Local", "Bytes", "Xferred", "", "%.0f",
&bytes_xferd, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_SEND_WIDTH, "Local", "Send", "Width", "", "%d",
&send_width, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_RECV_WIDTH, "Local", "Recv", "Width", "", "%d",
&recv_width, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SEND_OFFSET, "Local", "Send", "Offset", "", "%d",
&local_send_offset, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_RECV_OFFSET, "Local", "Recv", "Offset", "", "%d",
&local_recv_offset, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_RECV_ALIGN, "Local", "Recv", "Alignment", "", "%d",
&local_recv_align, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SEND_ALIGN, "Local", "Send", "Alignment", "", "%d",
&local_send_align, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SEND_DIRTY_COUNT, "Local", "Send", "Dirty", "Count",
"%d", &loc_dirty_count, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_RECV_DIRTY_COUNT, "Local", "Recv", "Dirty", "Count",
"%d", &loc_dirty_count, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_RECV_CLEAN_COUNT, "Local", "Recv", "Clean", "Count",
"%d", &loc_clean_count, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_CPU_UTIL, "Local", "CPU", "Util", "%", "%.2f",
&local_cpu_utilization, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PERCENT_USER, "Local", "CPU", "User", "%", "%.2f",
&lib_local_cpu_stats.cpu_user, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PERCENT_SYSTEM,
"Local", "CPU", "System", "%", "%.2f",
&lib_local_cpu_stats.cpu_system, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PERCENT_IOWAIT,
"Local", "CPU", "I/O", "%", "%.2f",
&lib_local_cpu_stats.cpu_iowait, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PERCENT_IRQ,
"Local", "CPU", "IRQ", "%", "%.2f",
&lib_local_cpu_stats.cpu_irq, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PERCENT_SWINTR,
"Local", "CPU", "swintr", "%", "%.2f",
&lib_local_cpu_stats.cpu_swintr, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PEAK_UTIL, "Local", "Peak", "Per CPU", "Util %",
"%.2f", &lib_local_cpu_stats.peak_cpu_util, 1, 0,
NETPERF_TYPE_FLOAT);
set_output_elt(LOCAL_CPU_PEAK_ID, "Local", "Peak", "Per CPU", "ID", "%d",
&lib_local_cpu_stats.peak_cpu_id, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_CPU_BIND, "Local", "CPU", "Bind", "", "%d",
&local_proc_affinity, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SD, "Local", "Service", "Demand", "", "%.3f",
&local_service_demand_double, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(SD_UNITS, "Service", "Demand", "Units", "", "%s",
sd_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_CPU_METHOD, "Local", "CPU", "Util", "Method", "%c",
&local_cpu_method, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_CPU_COUNT, "Local", "CPU", "Count", "", "%d",
&lib_num_loc_cpus, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_NODELAY, "Local", "NODELAY", "", "", "%d",
&loc_nodelay, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_CORK, "Local", "Cork", "", "", "%d",
&loc_tcpcork, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RSS_SIZE_REQ, "Remote", "Send Socket", "Size", "Requested",
"%d", &rss_size_req, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RSS_SIZE, "Remote", "Send Socket", "Size", "Initial", "%d",
&rss_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RSS_SIZE_END, "Remote", "Send Socket", "Size", "Final", "%d",
&rss_size_end, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RSR_SIZE_REQ, "Remote", "Recv Socket", "Size", "Requested",
"%d", &rsr_size_req, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RSR_SIZE, "Remote", "Recv Socket", "Size", "Initial", "%d",
&rsr_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(RSR_SIZE_END, "Remote", "Recv Socket", "Size", "Final", "%d",
&rsr_size_end, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SEND_SIZE, "Remote", "Send", "Size", "", "%d",
&remote_send_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_RECV_SIZE, "Remote", "Recv", "Size", "", "%d",
&remote_recv_size, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SEND_CALLS, "Remote", "Send", "Calls", "", "%"PRIu64,
&remote_send_calls, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(REMOTE_RECV_CALLS, "Remote", "Recv", "Calls", "", "%"PRIu64,
&remote_receive_calls, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(REMOTE_BYTES_PER_RECV, "Remote", "Bytes", "Per", "Recv",
"%.2f", &remote_bytes_per_recv, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_BYTES_PER_SEND, "Remote", "Bytes", "Per", "Send",
"%.2f", &remote_bytes_per_send, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_BYTES_RECVD, "Remote", "Bytes", "Received", "",
"%"PRIu64, &remote_bytes_received, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(REMOTE_BYTES_SENT, "Remote", "Bytes", "Sent", "", "%"PRIu64,
&remote_bytes_sent, 1, 0, NETPERF_TYPE_UINT64);
set_output_elt(REMOTE_BYTES_XFERD, "Remote", "Bytes", "Xferred", "", "%.0f",
&remote_bytes_xferd, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_SEND_WIDTH, "Remote", "Send", "Width", "", "%d",
&remote_send_width, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_RECV_WIDTH, "Remote", "Recv", "Width", "", "%d",
&remote_recv_width, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SEND_OFFSET, "Remote", "Send", "Offset", "", "%d",
&remote_send_offset, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_RECV_OFFSET, "Remote", "Recv", "Offset", "", "%d",
&remote_recv_offset, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_RECV_ALIGN, "Remote", "Recv", "Alignment", "", "%d",
&remote_recv_align, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SEND_ALIGN, "Remote", "Send", "Alignment", "", "%d",
&remote_send_align, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SEND_DIRTY_COUNT, "Remote", "Send", "Dirty", "Count",
"%d", &rem_dirty_count, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_RECV_DIRTY_COUNT, "Remote", "Recv", "Dirty", "Count",
"%d", &rem_dirty_count, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_RECV_CLEAN_COUNT, "Remote", "Recv", "Clean", "Count",
"%d", &rem_clean_count, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_CPU_UTIL, "Remote", "CPU", "Util", "%", "%.2f",
&remote_cpu_utilization, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PERCENT_USER, "Remote", "CPU", "User", "%", "%.2f",
&lib_remote_cpu_stats.cpu_user, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PERCENT_SYSTEM,
"Remote", "CPU", "System", "%", "%.2f",
&lib_remote_cpu_stats.cpu_system, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PERCENT_IOWAIT,
"Remote", "CPU", "I/O", "%", "%.2f",
&lib_remote_cpu_stats.cpu_iowait, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PERCENT_IRQ,
"Remote", "CPU", "IRQ", "%", "%.2f",
&lib_remote_cpu_stats.cpu_irq, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PERCENT_SWINTR,
"Remote", "CPU", "swintr", "%", "%.2f",
&lib_remote_cpu_stats.cpu_swintr, 1, 0, NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PEAK_UTIL, "Remote", "Peak", "Per CPU", "Util %",
"%.2f", &lib_remote_cpu_stats.peak_cpu_util, 1, 0,
NETPERF_TYPE_FLOAT);
set_output_elt(REMOTE_CPU_PEAK_ID, "Remote", "Peak", "Per CPU", "ID", "%d",
&lib_remote_cpu_stats.peak_cpu_id, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_CPU_BIND, "Remote", "CPU", "Bind", "", "%d",
&remote_proc_affinity, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SD, "Remote", "Service", "Demand", "", "%.3f",
&remote_service_demand_double, 1, 0, NETPERF_TYPE_DOUBLE);
set_output_elt(REMOTE_CPU_METHOD, "Remote", "CPU", "Util", "Method", "%c",
&remote_cpu_method, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_CPU_COUNT, "Remote", "CPU", "Count", "", "%d",
&lib_num_rem_cpus, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_NODELAY, "Remote", "NODELAY", "", "", "%d",
&rem_nodelay, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_CORK, "Remote", "Cork", "", "", "%d",
&rem_tcpcork, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_DRIVER_NAME, "Local", "Driver", "Name", "", "%s",
deprecated_str, 1, OMNI_WANT_LOC_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_DRIVER_VERSION, "Local", "Driver", "Version", "", "%s",
deprecated_str, 1, OMNI_WANT_LOC_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_DRIVER_FIRMWARE, "Local", "Driver", "Firmware", "",
"%s", deprecated_str, 1, OMNI_WANT_LOC_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_DRIVER_BUS, "Local", "Driver", "Bus", "", "%s",
deprecated_str, 1, OMNI_WANT_LOC_DRVINFO, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_DRIVER_NAME, "Remote", "Driver", "Name", "", "%s",
deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_DRIVER_VERSION, "Remote", "Driver", "Version", "",
"%s", deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_DRIVER_FIRMWARE, "Remote", "Driver", "Firmware", "",
"%s", deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_DRIVER_BUS, "Remote", "Driver", "Bus", "", "%s",
deprecated_str, 1, OMNI_WANT_REM_DRVINFO,
NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_INTERFACE_SUBDEVICE, "Local", "Interface", "Subdevice",
"", "0x%.4x", &local_interface_subdevice, 1,
OMNI_WANT_LOC_IFIDS, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_INTERFACE_DEVICE, "Local", "Interface", "Device", "",
"0x%.4x", &local_interface_device, 1, OMNI_WANT_LOC_IFIDS,
NETPERF_TYPE_INT32);
set_output_elt(LOCAL_INTERFACE_SUBVENDOR, "Local", "Interface", "Subvendor",
"", "0x%.4x", &local_interface_subvendor, 1,
OMNI_WANT_LOC_IFIDS, NETPERF_TYPE_UINT32);
set_output_elt(LOCAL_INTERFACE_VENDOR, "Local", "Interface", "Vendor", "",
"0x%.4x", &local_interface_vendor, 1, OMNI_WANT_LOC_IFIDS,
NETPERF_TYPE_UINT32);
set_output_elt(REMOTE_INTERFACE_SUBDEVICE, "Remote", "Interface",
"Subdevice", "", "0x%.4x", &remote_interface_subdevice, 1,
OMNI_WANT_REM_IFIDS, NETPERF_TYPE_UINT32);
set_output_elt(REMOTE_INTERFACE_DEVICE, "Remote", "Interface", "Device", "",
"0x%.4x", &remote_interface_device, 1, OMNI_WANT_REM_IFIDS,
NETPERF_TYPE_UINT32);
set_output_elt(REMOTE_INTERFACE_SUBVENDOR, "Remote", "Interface",
"Subvendor", "", "0x%.4x", &remote_interface_subvendor, 1,
OMNI_WANT_REM_IFIDS, NETPERF_TYPE_UINT32);
set_output_elt(REMOTE_INTERFACE_VENDOR, "Remote", "Interface", "Vendor", "",
"0x%.4x", &remote_interface_vendor, 1, OMNI_WANT_REM_IFIDS,
NETPERF_TYPE_UINT32);
set_output_elt(LOCAL_INTERFACE_NAME, "Local", "Interface", "Name", "", "%s",
deprecated_str, 1, OMNI_WANT_LOC_IFNAME,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_INTERFACE_NAME, "Remote", "Interface", "Name", "",
"%s", deprecated_str, 1, OMNI_WANT_REM_IFNAME,
NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_INTERFACE_SLOT, "Local", "Interface", "Slot", "", "%s",
deprecated_str, 1, OMNI_WANT_LOC_IFSLOT,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_INTERFACE_SLOT, "Remote", "Interface", "Slot", "",
"%s", deprecated_str, 1, OMNI_WANT_REM_IFSLOT,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_MACHINE, "Remote", "Machine", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_VERSION, "Remote", "Version", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_RELEASE, "Remote", "Release", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_SYSNAME, "Remote", "Sysname", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_MACHINE, "Local", "Machine", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_VERSION, "Local", "Version", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_RELEASE, "Local", "Release", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_SYSNAME, "Local", "Sysname", "", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_INTERVAL_USECS, "Remote", "Interval", "Usecs", "",
"%d", &remote_interval_usecs, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_INTERVAL_BURST, "Remote", "Interval", "Burst", "",
"%d", &remote_interval_burst, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SECURITY_ENABLED, "Local", "OS", "Security", "Enabled",
"%s", deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_SECURITY_TYPE, "Local", "OS", "Security", "Type", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_SECURITY_SPECIFIC, "Local", "OS", "Security",
"Specific", "%s", deprecated_str, 1, 0,
NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_SECURITY_ENABLED_NUM, "Local", "OS", "Security",
"Enabled Num", "%d", &local_security_enabled_num, 1, 0,
NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SECURITY_TYPE_ID, "Local", "OS", "Security", "Type ID",
"%d", &local_security_type_id, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SECURITY_ENABLED, "Remote", "OS", "Security",
"Enabled", "%s", deprecated_str, 1, 0,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_SECURITY_TYPE, "Remote", "OS", "Security", "Type",
"%s", deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_SECURITY_SPECIFIC, "Remote", "OS", "Security",
"Specific", "%s", deprecated_str, 1, 0,
NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_SECURITY_ENABLED_NUM, "Remote", "OS", "Security",
"Enabled", "%d", &remote_security_enabled_num, 1, 0,
NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SECURITY_TYPE_ID, "Remote", "OS", "Security", "Type",
"%d", &remote_security_type_id, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_INTERVAL_USECS, "Local", "Interval", "Usecs", "", "%d",
&interval_usecs, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_INTERVAL_BURST, "Local", "Interval", "Burst", "", "%d",
&interval_burst, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SYSTEM_MODEL, "Remote", "System", "Model", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_CPU_MODEL, "Remote", "CPU", "Model", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_CPU_FREQUENCY, "Remote", "CPU", "Frequency", "MHz",
"%d", &remote_cpu_frequency, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SYSTEM_MODEL, "Local", "System", "Model", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_CPU_MODEL, "Local", "CPU", "Model", "", "%s",
deprecated_str, 1, 0, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_CPU_FREQUENCY, "Local", "CPU", "Frequency", "MHz", "%d",
&local_cpu_frequency, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(MIN_LATENCY, "Minimum", "Latency", "Microseconds", "", "%d",
&min_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);
set_output_elt(MAX_LATENCY, "Maximum", "Latency", "Microseconds", "", "%d",
&max_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);
set_output_elt(P50_LATENCY, "50th", "Percentile", "Latency", "Microseconds",
"%d", &p50_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);
set_output_elt(P90_LATENCY, "90th", "Percentile", "Latency", "Microseconds",
"%d", &p90_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);
set_output_elt(P99_LATENCY, "99th", "Percentile", "Latency", "Microseconds",
"%d", &p99_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_INT32);
set_output_elt(MEAN_LATENCY, "Mean", "Latency", "Microseconds", "", "%.2f",
&mean_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_DOUBLE);
set_output_elt(STDDEV_LATENCY, "Stddev", "Latency", "Microseconds", "",
"%.2f", &stddev_latency, 0, OMNI_WANT_STATS, NETPERF_TYPE_DOUBLE);
set_output_elt(LOCAL_SOCKET_PRIO, "Local", "Socket", "Priority", "", "%d",
&local_socket_prio, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SOCKET_PRIO, "Remote", "Socket", "Priority", "", "%d"
, &remote_socket_prio, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_SOCKET_TOS, "Local", "Socket", "TOS", "", "0x%.2x",
&local_socket_tos, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(REMOTE_SOCKET_TOS, "Remote", "Socket", "TOS", "", "0x%.2x",
&remote_socket_tos, 1, 0, NETPERF_TYPE_INT32);
set_output_elt(LOCAL_CONG_CONTROL, "Local", "Congestion", "Control",
"Algorithm", "%s", local_cong_control, 0,
OMNI_WANT_LOC_CONG, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_CONG_CONTROL, "Remote", "Congestion", "Control",
"Algorithm", "%s", remote_cong_control, 0,
OMNI_WANT_REM_CONG, NETPERF_TYPE_CHAR);
set_output_elt(LOCAL_FILL_FILE, "Local", "Fill", "File", "", "%s",
local_fill_file, 0, 0, NETPERF_TYPE_CHAR);
set_output_elt(REMOTE_FILL_FILE, "Remote", "Fill", "File", "", "%s",
remote_fill_file, 0, 0, NETPERF_TYPE_CHAR);
set_output_elt(OUTPUT_END, "This", "Is", "The", "End", "%s",
NULL, 0, 0, NETPERF_TYPE_CHAR);
}
void
print_omni_init() {
int i,j;
if (debug) {
fprintf(where,"%s entered\n",
__FUNCTION__);
fflush(where);
}
/* why is this before the if you ask? because some of the output
specifiers are char * rather than char[] and when I wanted to
start setting output_group flags I was needing to call
print_omni_init() before the char * 's were malloced, which meant
the netperf_output_source got NULL pointers. there is
undoubtedly a cleaner way to do all this. raj 20110629 */
print_omni_init_list();
if (printing_initialized) return;
printing_initialized = 1;
/* belts and suspenders */
for (j = 0; j < NETPERF_MAX_BLOCKS; j++)
for (i = 0; i < NETPERF_OUTPUT_MAX; i++)
output_list[j][i] = OUTPUT_END;
if (output_selection_spec) {
parse_output_selection(output_selection_spec);
}
else {
set_output_list_by_test();
}
}
/* why? because one cannot simply pass a pointer to snprintf - well
except when it is expecting one... */
int
my_snprintf(char *buffer, size_t size, netperf_output_elt_t *output_elt)
{
switch (output_elt->output_type) {
case NETPERF_TYPE_CHAR:
return snprintf(buffer, size,
output_elt->format,
(char *)output_elt->display_value);
break;
case NETPERF_TYPE_INT32:
return snprintf(buffer, size,
output_elt->format,
*(int *)(output_elt->display_value));
break;
case NETPERF_TYPE_UINT32:
return snprintf(buffer, size,
output_elt->format,
*(unsigned int *)(output_elt->display_value));
break;
case NETPERF_TYPE_INT64:
return snprintf(buffer, size,
output_elt->format,
*(long long *)(output_elt->display_value));
break;
case NETPERF_TYPE_UINT64:
return snprintf(buffer, size,
output_elt->format,
*(unsigned long long *)(output_elt->display_value));
break;
case NETPERF_TYPE_FLOAT:
return snprintf(buffer, size,
output_elt->format,
*(float *)(output_elt->display_value));
break;
case NETPERF_TYPE_DOUBLE:
return snprintf(buffer, size,
output_elt->format,
*(double *)(output_elt->display_value));
break;
default:
fprintf(stderr,
"Unknown/unsupported output_elt output_type of %d\n",
output_elt->output_type);
fflush(stderr);
exit(-1);
}
}
void
print_omni_csv()
{
int i,j,k,buflen,vallen;
char *hdr1 = NULL;
char *val1 = NULL;
char *h1 = NULL;
char *v1 = NULL;
char tmpval[1024];
buflen = 0;
for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
for (j = 0;
((j < NETPERF_OUTPUT_MAX) &&
(output_list[i][j] != OUTPUT_END));
j++) {
if ((netperf_output_source[output_list[i][j]].format != NULL) &&
(netperf_output_source[output_list[i][j]].display_value != NULL)) {
vallen =
my_snprintf(tmpval,
1024,
&(netperf_output_source[output_list[i][j]]));
if (vallen == -1) {
fprintf(where,"my_snprintf failed on %s with format %s\n",
netperf_output_enum_to_str(j),
netperf_output_source[output_list[i][j]].format);
fflush(where);
}
vallen += 1; /* forget not the terminator */
}
else
vallen = 0;
if (vallen >
netperf_output_source[output_list[i][j]].tot_line_len)
netperf_output_source[output_list[i][j]].tot_line_len = vallen;
buflen +=
netperf_output_source[output_list[i][j]].tot_line_len;
}
}
if (print_headers) hdr1 = malloc(buflen + 1);
val1 = malloc(buflen + 1);
if (((hdr1 == NULL) && (print_headers)) ||
(val1 == NULL)) {
fprintf(where,"unable to allocate output buffers\n");
fflush(where);
exit(-1);
}
if (print_headers) memset(hdr1,' ',buflen + 1);
memset(val1,' ',buflen + 1);
/* ostensibly, we now "know" that we have enough space in all our
strings, and we have spaces where we want them etc */
h1 = hdr1;
v1 = val1;
for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
for (j = 0;
((j < NETPERF_OUTPUT_MAX) &&
(output_list[i][j] != OUTPUT_END));
j++) {
int len;
len = 0;
if (print_headers) {
for (k = 0; ((k < 4) &&
(NULL !=
netperf_output_source[output_list[i][j]].line[k]) &&
(strcmp("",netperf_output_source[output_list[i][j]].line[k]))); k++) {
len = sprintf(h1,
"%s",
netperf_output_source[output_list[i][j]].line[k]);
*(h1 + len) = ' ';
/* now move to the next starting column. for csv we aren't worried
about alignment between the header and the value lines */
h1 += len + 1;
}
*(h1 - 1) = ',';
}
if ((netperf_output_source[output_list[i][j]].format != NULL) &&
(netperf_output_source[output_list[i][j]].display_value != NULL)) {
/* tot_line_len is bogus here, but should be "OK" ? */
len = my_snprintf(v1,
netperf_output_source[output_list[i][j]].tot_line_len,
&(netperf_output_source[output_list[i][j]]));
/* nuke the trailing \n" from the string routine. */
*(v1 + len) = ',';
v1 += len + 1;
}
else {
/* we need a ',' even if there is no value */
*v1 = ',';
v1 += 2;
}
}
}
/* ok, _now_ null terminate each line by nuking the last comma. do
we have an OBOB here? */
if (print_headers) *(h1-1) = 0;
*(v1-1) = 0;
/* and now spit it out, but only if it is going to have something
in it. we don't want a bunch of blank lines or nulls... */
if (output_list[0][0] != OUTPUT_END) {
if (print_headers) printf("%s\n",hdr1);
printf("%s\n",val1);
}
if (hdr1 != NULL) free(hdr1);
if (val1 != NULL) free(val1);
}
void
print_omni_keyword()
{
/* this one should be the simplest of all - no buffers to allocate,
just spit it all out. raj 20080805 */
int i,j;
char tmpval[1024];
int vallen;
for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
for (j = 0;
((j < NETPERF_OUTPUT_MAX) &&
(output_list[i][j] != OUTPUT_END));
j++) {
if ((netperf_output_source[output_list[i][j]].format != NULL) &&
(netperf_output_source[output_list[i][j]].display_value != NULL)) {
vallen =
my_snprintf(tmpval,
1024,
&(netperf_output_source[output_list[i][j]]));
if (vallen == -1) {
snprintf(tmpval,
1024,
"my_snprintf failed with format %s\n",
netperf_output_source[output_list[i][j]].format);
}
fprintf(where,
"%s=%s\n",netperf_output_enum_to_str(output_list[i][j]),
tmpval);
}
}
}
fflush(where);
}
void
print_omni_human()
{
int i,j,k,buflen,buflen_max;
char *hdr[4];
char *val1 = NULL;
char tmpval[1024]; /* excessive, but we may have the command line */
int vallen;
for (k = 0; k < 4; k ++) {
hdr[k] = NULL;
}
/* decisions, decisions... walk the list twice to only need to
allocate the charcter buffers once, or walk it once and possibly
reallocate them as I go... oh, lets walk it twice just for fun to
start. since only now do we know that the values are around to be
printed, we should try the snprintf for the value and see how
much space it wants and update max_line_len accordingly */
buflen_max = 0;
for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
buflen = 0;
for (j = 0;
((j < NETPERF_OUTPUT_MAX) &&
(output_list[i][j] != OUTPUT_END));
j++) {
if ((netperf_output_source[output_list[i][j]].format != NULL) &&
(netperf_output_source[output_list[i][j]].display_value !=
NULL))
/* need to count the \n */
vallen = my_snprintf(tmpval,
1024,
&(netperf_output_source[output_list[i][j]])) + 1;
else
vallen = 0;
if (vallen >
netperf_output_source[output_list[i][j]].max_line_len)
netperf_output_source[output_list[i][j]].max_line_len = vallen;
buflen +=
netperf_output_source[output_list[i][j]].max_line_len + 1;
}
if (buflen > buflen_max)
buflen_max = buflen;
}
/* more belts and suspenders */
for (k = 0; (k < 4) && (print_headers); k++) {
hdr[k] = malloc(buflen_max+1);
}
val1 = malloc(buflen_max+1);
/* we could probably be more succinct here but perhaps the compiler
can figure that out for us :) */
for (k = 0; (k < 4) && (print_headers); k++) {
if (hdr[k] == NULL) {
fprintf(where,"Unable to allocate output buffers\n");
fflush(where);
exit(-1);
}
}
/* ostensibly, we now "know" that we have enough space in all our
strings, and we have spaces where we want them etc */
for (i = 0; i < NETPERF_MAX_BLOCKS; i++) {
char *h[4];
char *v1 = val1;
for (k = 0; k < 4; k++) h[k] = hdr[k];
/* we want to blank things out each time since we skip around a lot */
for (k = 0; (k < 4) && (print_headers); k++) {
memset(hdr[k],' ',buflen_max+1);
}
memset(val1,' ',buflen_max+1);
for (j = 0;
((j < NETPERF_OUTPUT_MAX) &&
(output_list[i][j] != OUTPUT_END));
j++) {
if (print_headers) {
for (k = 0; k < 4; k++) {
memcpy(h[k],
netperf_output_source[output_list[i][j]].line[k],
strlen(netperf_output_source[output_list[i][j]].line[k]));
}
}
if ((netperf_output_source[output_list[i][j]].format != NULL) &&
(netperf_output_source[output_list[i][j]].display_value != NULL)) {
int len;
len = my_snprintf(v1,
netperf_output_source[output_list[i][j]].max_line_len,
&(netperf_output_source[output_list[i][j]]));
/* nuke the trailing \n" from the string routine. */
*(v1 + len) = ' ';
}
/* now move to the next starting column */
for (k = 0; (k < 4) && (print_headers); k++) {
h[k] +=
netperf_output_source[output_list[i][j]].max_line_len + 1;
}
v1 += netperf_output_source[output_list[i][j]].max_line_len + 1;
}
/* ok, _now_ null terminate each line. do we have an OBOB here? */
for (k = 0; (k < 4) && (print_headers); k++) {
*h[k] = 0;
}
*v1 = 0;
/* and now spit it out, but only if it is going to have something
in it. we don't want a bunch of blank lines or nulls... at some
point we might want to work backwards collapsine whitespace from
the right but for now, we won't bother */
if (output_list[i][0] != OUTPUT_END) {
if (i > 0) printf("\n"); /* we want a blank line between blocks ? */
for (k = 0; (k < 4) && (print_headers); k++) {
printf("%s\n",hdr[k]);
}
printf("%s\n",val1);
}
};
for (k = 0; k < 4; k++) {
if (hdr[k] != NULL) free(hdr[k]);
}
}
void
print_omni()
{
print_omni_init();
if (debug > 2)
dump_netperf_output_source(where);
switch (netperf_output_mode) {
case CSV:
print_omni_csv();
break;
case KEYVAL:
print_omni_keyword();
break;
case HUMAN:
print_omni_human();
break;
default:
fprintf(where,"Yo Rick! There is a bug in netperf_output_mode!\n");
fflush(where);
exit(-1);
}
}
/* for the next few routines (connect, accept, send, recv,
disconnect/close) we will use a return of -1 to mean times up, -2
to mean a transient error (eg ENOBUFS on a UDP send call) and -3 to
mean hard error. this means it is ok for the connect routine to
return a 0 (zero) if that happens to be the fd/SOCKET we get and in
theory we will be able to support zero-length messages on those
protocols which support it. all in theory of course. raj
2008-01-09 */
int
connect_data_socket(SOCKET send_socket, struct addrinfo *remote_res, int dont_give_up)
{
int ret;
/* Connect up to the remote port on the data socket */
if ((ret = connect(send_socket,
remote_res->ai_addr,
remote_res->ai_addrlen)) == INVALID_SOCKET) {
if (SOCKET_EINTR(ret)) {
/* we interpret this to mean that the test is supposed to be
over, so return a value of -1 to the caller */
return -1;
}
if ((SOCKET_EADDRINUSE(ret)) || SOCKET_EADDRNOTAVAIL(ret) || dont_give_up) {
/* likely something our explicit bind() would have caught in
the past, so go get another port, via create_data_socket.
yes, this is a bit more overhead than before, but the
condition should be rather rare. we only get a new port if
this was a connection-including test like TCP_CRR or
TCP_CC. Otherwise we need to return an error. raj
2008-01-08 */
return -2;
}
else
/* -3 means there was an error */
return -3;
}
return 0;
}
static
int send_pktinfo(SOCKET data_socket, char *buffer, int len, struct sockaddr *destination, int destlen) {
#ifdef IP_PKTINFO
struct msghdr msg;
struct iovec iovec[1];
char msg_control[512];
struct cmsghdr *cmsg;
int cmsg_space = 0;
iovec[0].iov_base = buffer;
iovec[0].iov_len = len;
msg.msg_name = destination;
msg.msg_namelen = destlen;
msg.msg_iov = iovec;
msg.msg_iovlen = 1;
msg.msg_control = msg_control;
msg.msg_controllen = sizeof(msg_control);
msg.msg_flags = 0;
cmsg = CMSG_FIRSTHDR(&msg);
if (have_pktinfo) {
cmsg->cmsg_level = IPPROTO_IP;
cmsg->cmsg_type = IP_PKTINFO;
cmsg->cmsg_len = CMSG_LEN(sizeof(in_pktinfo));
*(struct in_pktinfo*)CMSG_DATA(cmsg) = in_pktinfo;
cmsg_space += CMSG_SPACE(sizeof(in_pktinfo));
}
msg.msg_controllen = cmsg_space;
return sendmsg(data_socket, &msg, 0);
#else
return -1;
#endif /* IP_PKTINFO */
}
int
send_data(SOCKET data_socket, struct ring_elt *send_ring, uint32_t bytes_to_send, struct sockaddr *destination, int destlen, int protocol) {
int len;
/* if the user has supplied a destination, we use sendto, otherwise
we use send. we ass-u-me blocking operations always, so no need
to check for eagain or the like. */
if (debug > 2) {
fprintf(where,
"%s sock %d, ring elt %p, bytes %d, dest %p, len %d\n",
__FUNCTION__,
data_socket,
send_ring,
bytes_to_send,
destination,
destlen);
fflush(where);
}
if (destination) {
if (have_pktinfo) {
len = send_pktinfo(data_socket,
send_ring->buffer_ptr,
bytes_to_send,
destination,
destlen);
}
else {
len = sendto(data_socket,
send_ring->buffer_ptr,
bytes_to_send,
#if defined(MSG_FASTOPEN)
(use_fastopen && protocol == IPPROTO_TCP) ? MSG_FASTOPEN : 0,
#else
0,
#endif
destination,
destlen);
}
}
else {
if (!use_write) {
len = send(data_socket,
send_ring->buffer_ptr,
bytes_to_send,
0);
}
else {
#ifndef WIN32
len = write(data_socket,
send_ring->buffer_ptr,
bytes_to_send);
#else
fprintf(where,"I'm sorry Dave I cannot write() under Windows\n");
fflush(where);
return -3;
#endif
}
}
if(len != bytes_to_send) {
/* don't forget that some platforms may do a partial send upon
receipt of the interrupt and not return an EINTR... */
if (SOCKET_EINTR(len) || (len >= 0))
{
/* we hit the end of a timed test. */
return -1;
}
/* if this is UDP it is possible to receive an ENOBUFS on the send
call and it would not be a fatal error. of course if we were
to return 0 then it would make the test think it was over when
it really wasn't. the question becomes what to do. for the
time being, the answer will likely be to return something like
-2 to indicate a non-fatal error happened on the send and let
the caller figure it out :) we won't actually check to see if
this is UDP - it is the author's experience in many, Many, MANY
years that the only time an ENOBUFS has been returned in a
netperf test has been with UDP. famous last words :) */
if (errno == ENOBUFS)
return -2;
else {
fprintf(where,"%s: data send error: %s (errno %d)\n",
__FUNCTION__, strerror(errno), errno);
return -3;
}
}
return len;
}
#if defined(__linux)
static int
recv_data_no_copy(SOCKET data_socket, struct ring_elt *recv_ring, uint32_t bytes_to_recv, struct sockaddr *source, netperf_socklen_t *sourcelen, uint32_t flags, uint32_t *num_receives) {
#ifndef SPLICE_F_MOVE
# define SPLICE_F_MOVE 0x01
#endif
#ifndef SPLICE_F_NONBLOCK
# define SPLICE_F_NONBLOCK 0x02
#endif
static int pfd[2] = {-1, -1};
static int fdnull = -1;
char *temp_message_ptr;
int bytes_left;
int bytes_recvd;
int my_recvs;
int my_flags = SPLICE_F_MOVE | SPLICE_F_NONBLOCK; /* values
suggested by
Eric Dumazet */
int ret;
if (pfd[0] == -1) {
if (pipe(pfd)) {
fprintf(where,
"%s pipe call failed with errno %d '%s'\n",
__FUNCTION__,
errno,
strerror(errno));
return -4; /* this will cause recv_data to do things the
old-fashioned way for the test */
}
if ((fdnull = open("/dev/null",O_WRONLY)) == -1) {
fprintf(where,
"%s open call failed with errno %d '%s'\n",
__FUNCTION__,
errno,
strerror(errno));
return -4;
}
}
/* receive data off the data_socket, ass-u-me-ing a blocking socket
all the way!-) 2008-01-08 */
my_recvs = 0;
bytes_left = bytes_to_recv;
if (debug > 1) {
fprintf(where,
"%s sock %d, ring elt %p, bytes %d, source %p, srclen %d, flags %x, num_recv %p\n",
__FUNCTION__,
data_socket,
recv_ring,
bytes_to_recv,
source,
(source != NULL) ? *sourcelen : -1,
flags,
num_receives);
fflush(where);
}
do {
bytes_recvd = splice(data_socket,
NULL,
pfd[1],
NULL,
bytes_left,
my_flags);
if (bytes_recvd > 0) {
/* per Eric Dumazet, we should just let this second splice call
move as many bytes as it can and not worry about how much.
this should make the call more robust when made on a system
under memory pressure */
splice(pfd[0], NULL, fdnull, NULL, 1 << 30, my_flags);
bytes_left -= bytes_recvd;
}
else {
break;
}
my_recvs++; /* should the pair of splices count as one? */
} while ((bytes_left > 0) && (flags & NETPERF_WAITALL));
*num_receives = my_recvs;
/* OK, we are out of the loop - now what? */
if (bytes_recvd < 0) {
/* did the timer hit, or was there an error? */
if (SOCKET_EINTR(bytes_recvd))
{
/* We hit the end of a timed test. */
return -1;
}
/* it was a hard error */
return -3;
}
/* this looks a little funny, but should be correct. if we had
NETPERF_WAITALL set and we got here, it means we got all the
bytes of the request/response. otherwise we would have hit the
error or end of test cases. if NETPERF_WAITALL isn't set, this
is a STREAM test, and we will have only made one call to recv, so
bytes_recvd will be accurate. */
if (bytes_left)
return bytes_recvd;
else
return bytes_to_recv;
}
#endif
static
int recv_pktinfo(SOCKET data_socket, char *message_ptr, int bytes_to_recv, int my_flags, struct sockaddr *source, netperf_socklen_t *sourcelen) {
#ifdef IP_PKTINFO
struct iovec my_iovec;
struct msghdr my_header;
struct cmsghdr *cmsg;
struct in_pktinfo *pktinfo;
char control_buf[512];
int onoff = 1;
int ret;
my_iovec.iov_base = message_ptr;
my_iovec.iov_len = bytes_to_recv;
my_header.msg_name = source;
my_header.msg_namelen = *sourcelen;
my_header.msg_iov = &my_iovec;
my_header.msg_iovlen = 1;
my_header.msg_control = control_buf;
my_header.msg_controllen = sizeof(control_buf);
/* not going to bother checking, if it doesn't work we are no
worse-off than we were before. we are going to ignore IPv6 for
the time being */
setsockopt(data_socket, IPPROTO_IP, IP_PKTINFO, &onoff, sizeof(onoff));
ret = recvmsg(data_socket, &my_header, 0);
if (ret >= 0) {
struct sockaddr_in me;
struct sockaddr_in clear;
netperf_socklen_t melen = sizeof(me);
for (cmsg = CMSG_FIRSTHDR(&my_header);
cmsg != NULL;
cmsg = CMSG_NXTHDR(&my_header, cmsg)) {
if (cmsg->cmsg_level == IPPROTO_IP && cmsg->cmsg_type == IP_PKTINFO) {
in_pktinfo = *(struct in_pktinfo *)CMSG_DATA(cmsg);
have_pktinfo = 1;
}
}
}
onoff = 0;
setsockopt(data_socket, IPPROTO_IP, IP_PKTINFO, &onoff, sizeof(onoff));
return ret;
#else
return -1;
#endif
}
int
recv_data(SOCKET data_socket, struct ring_elt *recv_ring, uint32_t bytes_to_recv, struct sockaddr *source, netperf_socklen_t *sourcelen, uint32_t flags, uint32_t *num_receives) {
char *temp_message_ptr;
int bytes_left;
int bytes_recvd;
int my_recvs;
int my_flags = 0; /* will we one day want to set MSG_WAITALL? */
#if defined(__linux)
int ret;
if (loc_rcvavoid == 1) {
ret = recv_data_no_copy(data_socket, recv_ring, bytes_to_recv, source, sourcelen, flags, num_receives);
if (ret != -4)
return ret;
else
loc_rcvavoid = 0;
}
#endif
/* receive data off the data_socket, ass-u-me-ing a blocking socket
all the way!-) 2008-01-08 */
my_recvs = 0;
bytes_left = bytes_to_recv;
temp_message_ptr = recv_ring->buffer_ptr;
if (debug > 1) {
fprintf(where,
"%s sock %d, ring elt %p, bytes %d, source %p, srclen %d, flags %x, num_recv %p\n",
__FUNCTION__,
data_socket,
recv_ring,
bytes_to_recv,
source,
(source != NULL) ? *sourcelen : -1,
flags,
num_receives);
fflush(where);
}
do {
if (source) {
/* call recvfrom it does look a little silly here inside the do
while, but I think it is ok - a UDP or other DGRAM or
SEQPACKET (?) socket, which should be the only time we
pass-in a source pointer will have a semantic that should get
us out of the dowhile on the first call anyway. if it
turns-out not to be the case, then we can hoist the if above
the do and put the dowhile in the else. */
if (use_pktinfo) {
bytes_recvd = recv_pktinfo(data_socket,
temp_message_ptr,
bytes_left,
my_flags,
source,
sourcelen);
use_pktinfo = 0;
}
else {
bytes_recvd = recvfrom(data_socket,
temp_message_ptr,
bytes_left,
my_flags,
source,
sourcelen);
}
}
else {
/* just call recv */
bytes_recvd = recv(data_socket,
temp_message_ptr,
bytes_left,
my_flags);
}
if (bytes_recvd > 0) {
bytes_left -= bytes_recvd;
temp_message_ptr += bytes_recvd;
}
else {
break;
}
my_recvs++;
} while ((bytes_left > 0) && (flags & NETPERF_WAITALL));
*num_receives = my_recvs;
/* OK, we are out of the loop - now what? */
if (bytes_recvd < 0) {
/* did the timer hit, or was there an error? */
if (SOCKET_EINTR(bytes_recvd))
{
/* We hit the end of a timed test. */
return -1;
}
if (SOCKET_EAGAIN(bytes_recvd) ||
SOCKET_EWOULDBLOCK(bytes_recvd)) {
return -2;
}
/* it was a hard error */
return -3;
}
/* this looks a little funny, but should be correct. if we had
NETPERF_WAITALL set and we got here, it means we got all the
bytes of the request/response. otherwise we would have hit the
error or end of test cases. if NETPERF_WAITALL isn't set, this
is a STREAM test, and we will have only made one call to recv, so
bytes_recvd will be accurate. */
if (bytes_left)
return bytes_recvd;
else
return bytes_to_recv;
}
int
close_data_socket(SOCKET data_socket, struct sockaddr *peer, int peerlen, int protocol)
{
int ret;
char buffer[4];
if (debug) {
fprintf(where,
"%s sock %d peer %p peerlen %d protocol %d\n",
__FUNCTION__,
data_socket,
peer,
peerlen,
protocol);
fflush(where);
}
if (protocol == IPPROTO_UDP) {
/* try to give the remote a signal. what this means if we ever
wanted to actually send zero-length messages remains to be seen
:) */
int i;
for (i = 0; i < 3; i++) {
if (peer)
ret = sendto(data_socket,
buffer,
0,
0,
peer,
peerlen);
else
ret = send(data_socket,
buffer,
0,
0);
if (SOCKET_EINTR(ret)) {
close(data_socket);
return -1;
}
}
}
ret = close(data_socket);
if (SOCKET_EINTR(ret)) {
/* end of test */
return -1;
}
else if (ret == 0) {
return ret;
}
else
return -3;
}
int
disconnect_data_socket(SOCKET data_socket, int initiate, int do_close, struct sockaddr *peer, int peerlen)
{
char buffer[4];
int bytes_recvd;
if (debug) {
fprintf(where,
"%s sock %d init %d do_close %d protocol %d\n",
__FUNCTION__,
data_socket,
initiate,
do_close,
protocol);
fflush(where);
}
/* at some point we'll need to abstract this a little. for now, if
the protocol is UDP, we try to send some number of zero-length
datagrams to allow the remote to get out of its loop without
having to wait for the padded timer to expire. if it isn't UDP,
we assume a reliable connection and can do the usual graceful
shutdown thing */
/* this needs to be revisited for the netperf receiving case when
the test is terminated by a Ctrl-C. raj 2012-01-24 */
if (protocol != IPPROTO_UDP) {
if (initiate)
shutdown(data_socket, SHUT_WR);
/* we are expecting to get either a return of zero indicating
connection close, or an error. of course, we *may* never
receive anything from the remote which means we probably really
aught to have a select here but until we are once bitten we
will remain twice bold. */
bytes_recvd = recv(data_socket,
buffer,
1,
0);
if (bytes_recvd != 0) {
/* connection close, call close. we assume that the requisite
number of bytes have been received */
if (SOCKET_EINTR(bytes_recvd))
{
/* We hit the end of a timed test. */
return -1;
}
return -3;
}
}
else {
int i;
for (i = 0; i < 3; i++) {
if (peer)
bytes_recvd = sendto(data_socket,
buffer,
0,
0,
peer,
peerlen);
else
bytes_recvd = send(data_socket,
buffer,
0,
0);
/* we only really care if the timer expired on us */
if (SOCKET_EINTR(bytes_recvd)) {
if (do_close)
close(data_socket);
return -1;
}
}
}
if (do_close)
close(data_socket);
return 0;
}
#ifdef HAVE_LINUX_TCP_H
static void
dump_tcp_info(struct tcp_info *tcp_info)
{
fprintf(stderr,
"tcpi_rto %d tcpi_ato %d tcpi_pmtu %d tcpi_rcv_ssthresh %d\n"
"tcpi_rtt %d tcpi_rttvar %d tcpi_snd_ssthresh %d tpci_snd_cwnd %d\n"
"tcpi_reordering %d tcpi_total_retrans %d\n",
tcp_info->tcpi_rto,
tcp_info->tcpi_ato,
tcp_info->tcpi_pmtu,
tcp_info->tcpi_rcv_ssthresh,
tcp_info->tcpi_rtt,
tcp_info->tcpi_rttvar,
tcp_info->tcpi_snd_ssthresh,
tcp_info->tcpi_snd_cwnd,
tcp_info->tcpi_reordering,
tcp_info->tcpi_total_retrans);
return;
}
#endif
static int
get_transport_retrans(SOCKET socket, int protocol) {
#ifdef HAVE_LINUX_TCP_H
struct tcp_info tcp_info;
int ret;
netperf_socklen_t infosize;
if (protocol != IPPROTO_TCP)
return -1;
infosize = sizeof(struct tcp_info);
if ((ret = getsockopt(socket,protocol,TCP_INFO,&tcp_info,&infosize)) < 0) {
if (debug) {
fprintf(where,
"%s: getsockopt errno %d %s\n",
__FUNCTION__,
errno,
strerror(errno));
fflush(where);
}
return -1;
}
else {
/* we assume that if we have LINUX_TCP_H we also have getenv */
if (debug > 1 || getenv("DUMP_TCP_INFO")) {
dump_tcp_info(&tcp_info);
}
return tcp_info.tcpi_total_retrans;
}
#else
return -1;
#endif
}
static void
get_transport_info(SOCKET socket, int *mss, int protocol)
{
netperf_socklen_t sock_opt_len;
int option;
sock_opt_len = sizeof(netperf_socklen_t);
switch (protocol) {
#if defined(IPPROTO_TCP) && defined(TCP_MAXSEG)
case IPPROTO_TCP:
option = TCP_MAXSEG;
break;
#endif
#if defined(IPPROTO_SCTP) && defined(SCTP_MAXSEG)
case IPPROTO_SCTP:
option = SCTP_MAXSEG;
break;
#endif
default:
*mss = -1;
return;
}
if (getsockopt(socket,
protocol,
option,
(char *)mss,
&sock_opt_len) == SOCKET_ERROR) {
fprintf(where,
"%s: getsockopt: errno %d\n",
__FUNCTION__,
errno);
fflush(where);
*mss = -1;
}
}
static void
get_transport_cong_control(SOCKET socket, int protocol, char cong_control[], int len)
{
#ifdef TCP_CONGESTION
int my_len = len;
if (protocol != IPPROTO_TCP) {
strncpy(cong_control,"TCP Only",len);
}
else if (getsockopt(socket,
protocol, TCP_CONGESTION, cong_control, &my_len) ==
SOCKET_ERROR) {
snprintf(cong_control,len,"%d errno",errno);
}
#else
strncpy(cong_control,"Unavailable",len);
#endif
cong_control[len-1] = '\0';
}
static void
set_transport_cong_control(SOCKET socket, int protocol, char cong_control[], int len)
{
#ifdef TCP_CONGESTION
if (protocol == IPPROTO_TCP) {
/* if it fails, we'll pick that up via the subsequent "get" */
setsockopt(socket, protocol, TCP_CONGESTION, cong_control, len);
}
#endif
}
static void
set_receive_timeout(SOCKET sock, int timeout)
{
#ifdef SO_RCVTIMEO
#ifndef WIN32
struct timeval foo;
foo.tv_sec = timeout;
foo.tv_usec = 0;
if (setsockopt(sock,SOL_SOCKET,SO_RCVTIMEO,&foo,sizeof(foo)) < 0) {
if (debug) {
fprintf(where,"Note - attempt to set a receive timeout on the data socket failed with errno %d (%s)\n",
errno,
strerror(errno));
fflush(where);
}
}
#endif
#endif
}
static SOCKET
omni_create_data_socket(struct addrinfo *res)
{
SOCKET temp_socket;
temp_socket = create_data_socket(res);
if (temp_socket != SOCKET_ERROR) {
if (local_cong_control_req[0] != '\0') {
set_transport_cong_control(temp_socket,
res->ai_protocol,
local_cong_control_req,
sizeof(local_cong_control_req));
}
if ((res->ai_protocol == IPPROTO_UDP) &&
(receive_timeout != -1)) {
set_receive_timeout(temp_socket, receive_timeout);
}
if (socket_debug) {
int one = 1;
setsockopt(temp_socket,
SOL_SOCKET,
SO_DEBUG,
&one,
sizeof(one));
}
}
return temp_socket;
}
/* choosing the default send size is a trifle more complicated than it
used to be as we have to account for different protocol limits */
#define UDP_LENGTH_MAX (0xFFFF - 28)
static int
choose_send_size(int lss, int protocol) {
int send_size;
if (lss > 0) {
send_size = lss_size;
/* we will assume that everyone has IPPROTO_UDP and thus avoid an
issue with Windows using an enum */
if ((protocol == IPPROTO_UDP) && (send_size > UDP_LENGTH_MAX))
send_size = UDP_LENGTH_MAX;
}
else {
send_size = 4096;
}
return send_size;
}
/* brain dead simple way to get netperf to emit a uuid. sadly, by this
point we will have already established the control connection but
those are the breaks. we do _NOT_ include a trailing newline
because we want to be able to use this in a script */
void
print_uuid(char remote_host[])
{
printf("%s",test_uuid);
}
#if defined(__linux)
/*
* Linux has this odd behavior where if the socket buffers are larger
* than a device's txqueuelen, the kernel will silently drop transmits
* which would not fit into the tx queue, and not pass an ENOBUFS
* error back to the application. As a result, a UDP stream test can
* report absurd transmit bandwidths (like 20Gb/s on a 1GbE NIC).
* This behavior can be avoided if you request extended error
* reporting on the socket. This is done by setting the IP_RECVERR
* socket option at the IP level.
*/
static void
enable_enobufs(int s)
{
struct protoent *pr;
int on = 1;
if ((pr = getprotobyname("ip")) == NULL) {
fprintf(where, "%s failed: getprotobyname\n",__FUNCTION__);
fflush(where);
return;
}
if (setsockopt(s, pr->p_proto, IP_RECVERR, (char *)&on, sizeof(on)) < 0) {
fprintf(where, "%s failed: setsockopt (errno %d)\n",__FUNCTION__,errno);
fflush(where);
return;
}
}
#endif
void
set_omni_request_flags(struct omni_request_struct *omni_request) {
/* we have no else clauses here because we previously set flags
to zero above raj 20090803 */
if (rem_nodelay)
omni_request->flags |= OMNI_NO_DELAY;
if (remote_use_sendfile)
omni_request->flags |= OMNI_USE_SENDFILE;
if (connection_test)
omni_request->flags |= OMNI_CONNECT_TEST;
if (remote_checksum_off)
omni_request->flags |= OMNI_CHECKSUM_OFF;
if (remote_cpu_usage)
omni_request->flags |= OMNI_MEASURE_CPU;
if (routing_allowed)
omni_request->flags |= OMNI_ROUTING_ALLOWED;
if (desired_output_groups & OMNI_WANT_REM_IFNAME)
omni_request->flags |= OMNI_WANT_IFNAME;
if (desired_output_groups & OMNI_WANT_REM_IFSLOT)
omni_request->flags |= OMNI_WANT_IFSLOT;
if (desired_output_groups & OMNI_WANT_REM_IFIDS)
omni_request->flags |= OMNI_WANT_IFIDS;
if (desired_output_groups & OMNI_WANT_REM_DRVINFO)
omni_request->flags |= OMNI_WANT_DRVINFO;
if (desired_output_groups & OMNI_WANT_REM_CONG)
omni_request->flags |= OMNI_WANT_REM_CONG;
if (use_fastopen)
omni_request->flags |= OMNI_FASTOPEN;
if (want_use_pktinfo)
omni_request->flags |= OMNI_USE_PKTINFO;
if (want_defer_accept)
omni_request->flags |= OMNI_WANT_DEFER_ACCEPT;
}
/* this code is intended to be "the two routines to run them all" for
BSDish sockets. it comes about as part of a desire to shrink the
code footprint of netperf and to avoid having so many blessed
routines to alter as time goes by. the downside is there will be
more "ifs" than there were before. raj 2008-01-07 */
void
send_omni_inner(char remote_host[], unsigned int legacy_caller, char header_str[])
{
int ret,rret;
int connected = 0;
int timed_out = 0;
int pad_time = 0;
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
struct sockaddr_storage remote_addr;
struct sockaddr_storage my_addr;
int remote_addr_len = sizeof(remote_addr);
netperf_socklen_t my_addr_len = sizeof(my_addr);
SOCKET data_socket;
int need_socket;
uint32_t temp_recvs;
char tmpfmt;
struct addrinfo *local_res;
struct addrinfo *remote_res;
struct omni_request_struct *omni_request;
struct omni_response_struct *omni_response;
struct omni_results_struct *omni_result;
#ifdef WANT_FIRST_BURST
int requests_outstanding = 0;
#endif
omni_request =
(struct omni_request_struct *)netperf_request.content.test_specific_data;
omni_response =
(struct omni_response_struct *)netperf_response.content.test_specific_data;
omni_result =
(struct omni_results_struct *)netperf_response.content.test_specific_data;
if (keep_histogram) {
if (first_burst_size > 0)
time_hist = HIST_new_n(first_burst_size + 1);
else
time_hist = HIST_new_n(1);
}
/* since we are now disconnected from the code that established the
control socket, and since we want to be able to use different
protocols and such, we are passed the name of the remote host and
must turn that into the test specific addressing information. */
complete_addrinfos(&remote_res,
&local_res,
remote_host,
socket_type,
protocol,
0);
if ( print_headers ) {
print_top_test_header(header_str,local_res,remote_res);
}
/* initialize a few counters */
need_socket = 1;
if (connection_test)
pick_next_port_number(local_res,remote_res);
/* 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);
}
confidence_iteration = 1;
init_stat();
send_ring = NULL;
recv_ring = NULL;
/* you will keep running the test until you get it right! :) */
while (((confidence < 0) && (confidence_iteration <= iteration_max)) ||
(confidence_iteration <= iteration_min)) {
trans_completed = 0;
bytes_xferd = 0.0;
remote_bytes_xferd = 0.0;
times_up = 0;
bytes_sent = 0;
bytes_received = 0;
local_send_calls = 0;
local_receive_calls = 0;
/* since we are tracking the number of outstanding requests for
timestamping purposes, and since the previous iteration of
using confidence intervals may not have completed all of them,
we now need to forget about them or we will mistakenly fill our
tracking array. raj 2011-03-14 */
if (keep_histogram) {
HIST_purge(time_hist);
}
#ifdef WANT_FIRST_BURST
/* we have to remember to reset the number of transactions
outstanding and the "congestion window for each new
iteration. raj 2006-01-31. */
requests_outstanding = 0;
#endif
/* if the command-line included requests to randomize the IP
addresses, then honor it. of course, this may not work all that
well for some tests... raj 20101129 */
if (local_mask_len)
random_ip_address(local_res, local_mask_len);
if (remote_mask_len)
random_ip_address(remote_res, remote_mask_len);
data_socket = omni_create_data_socket(local_res);
if (data_socket == INVALID_SOCKET) {
perror("netperf: send_omni: unable to create data socket");
exit(1);
}
#if defined(__linux)
/* we really only need this for a UDP_STREAM test. we particularly
do not want it for a CC or CRR test. raj 2012-08-06 */
if ((protocol == IPPROTO_UDP) &&
NETPERF_XMIT_ONLY(direction)) {
enable_enobufs(data_socket);
}
#endif
need_socket = 0;
/* we need to consider if this is a request/response test, if we
are receiving, if we are sending, etc, when setting-up our recv
and send buffer rings. we should only need to do this once, and
that would be when the relevant _ring variable is NULL. raj
2008-01-18 */
if (direction & NETPERF_XMIT) {
if (is_multicast_addr(remote_res)) {
set_multicast_ttl(data_socket);
}
if (NULL == send_ring) {
if (req_size > 0) {
/* request/response test */
if (send_width == 0) send_width = 1;
bytes_to_send = req_size;
}
else {
/* stream test */
if (send_size == 0) {
send_size = choose_send_size(lss_size,protocol);
}
if (send_width == 0)
send_width = (lss_size/send_size) + 1;
if (send_width == 1) send_width++;
bytes_to_send = send_size;
}
send_ring = allocate_buffer_ring(send_width,
bytes_to_send,
local_send_align,
local_send_offset);
if (debug) {
fprintf(where,
"%s: %d entry send_ring obtained...\n",
__FUNCTION__,
send_width);
}
}
}
if (direction & NETPERF_RECV) {
/* do we need to join a multicast group? */
if (is_multicast_addr(local_res)) {
join_multicast_addr(data_socket, local_res);
}
/* do we need to allocate a recv_ring? */
if (NULL == recv_ring) {
if (rsp_size > 0) {
if (recv_width == 0) recv_width = 1;
bytes_to_recv = rsp_size;
}
else {
/* stream test */
if (recv_size == 0) {
if (lsr_size > 0) {
recv_size = lsr_size;
}
else {
recv_size = 4096;
}
}
if (recv_width == 0) {
recv_width = (lsr_size/recv_size) + 1;
if (recv_width == 1) recv_width++;
}
bytes_to_recv = recv_size;
}
recv_ring = allocate_buffer_ring(recv_width,
bytes_to_recv,
local_recv_align,
local_recv_offset);
if (debug) {
fprintf(where,
"%s: %d entry recv_ring obtained...\n",
__FUNCTION__,
recv_width);
}
}
}
if (!no_control) {
/* Tell the remote end to do a listen or otherwise prepare for
what is to come. 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 values 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 probably be no alignment
alterations. */
netperf_request.content.request_type = DO_OMNI;
omni_request->flags = 0;
omni_request->send_buf_size = rss_size_req;
omni_request->send_size = remote_send_size_req;
omni_request->send_alignment = remote_send_align;
omni_request->send_offset = remote_send_offset;
omni_request->send_width = send_width;
omni_request->request_size = req_size;
omni_request->recv_buf_size = rsr_size_req;
omni_request->receive_size = remote_recv_size_req;
omni_request->recv_alignment = remote_recv_align;
omni_request->recv_offset = remote_recv_offset;
omni_request->recv_width = recv_width;
omni_request->response_size = rsp_size;
omni_request->socket_prio = remote_socket_prio;
omni_request->socket_tos = remote_socket_tos;
set_omni_request_flags(omni_request);
/* perhaps this should be made conditional on
remote_cong_control_req[0] not being NULL? */
strncpy(omni_request->cong_control,
remote_cong_control_req,
sizeof(omni_request->cong_control));
omni_request->cong_control[sizeof(omni_request->cong_control) - 1] =
'\0';
if (want_keepalive)
omni_request->flags |= OMNI_WANT_KEEPALIVE;
omni_request->cpu_rate = remote_cpu_rate;
if (test_time)
omni_request->test_length = test_time;
else
omni_request->test_length = test_trans * -1;
omni_request->so_rcvavoid = rem_rcvavoid;
omni_request->so_sndavoid = rem_sndavoid;
omni_request->send_dirty_count = rem_dirty_count;
omni_request->recv_dirty_count = rem_dirty_count;
omni_request->recv_clean_count = rem_clean_count;
omni_request->data_port = atoi(remote_data_port);
omni_request->ipfamily = af_to_nf(remote_res->ai_family);
omni_request->socket_type = hst_to_nst(socket_type);
omni_request->protocol = protocol;
omni_request->interval_burst = remote_interval_burst;
omni_request->interval_usecs = remote_interval_usecs;
omni_request->direction = 0;
/* yes, the sense here is correct - if we are transmitting, they
receive, if we are receiving, they are transmitting... */
if (direction & NETPERF_XMIT)
omni_request->direction |= NETPERF_RECV;
if (direction & NETPERF_RECV)
omni_request->direction |= NETPERF_XMIT;
/* some tests may require knowledge of our local addressing. such
tests will for the time being require that the user specify a
local IP/name so we can extract them from the data_socket. */
getsockname(data_socket, (struct sockaddr *)&my_addr, &my_addr_len);
ret = get_sockaddr_family_addr_port(&my_addr,
nf_to_af(omni_request->ipfamily),
omni_request->netperf_ip,
&(omni_request->netperf_port));
ret = get_sockaddr_family_addr_port((struct sockaddr_storage *)remote_res->ai_addr,
nf_to_af(omni_request->ipfamily),
omni_request->netserver_ip,
&(omni_request->data_port));
/* if the user didn't explicitly set the remote data address we
don't want to pass along the one we picked implicitly, or a
netserver sitting behind a (BLETCH) NAT will be asked to try
to bind to the "public" IP. */
if (!explicit_data_address) {
omni_request->netserver_ip[0] = 0;
omni_request->netserver_ip[1] = 0;
omni_request->netserver_ip[2] = 0;
omni_request->netserver_ip[3] = 0;
}
if (debug > 1) {
fprintf(where,"netperf: %s: requesting OMNI test\n",__FUNCTION__);
}
strncpy(omni_request->fill_file,
remote_fill_file,
sizeof(omni_request->fill_file));
send_request_n(OMNI_REQUEST_CONV_CUTOFF);
/* the response from the remote should contain all the relevant
socket and other parameters we need to know for this test.
so, we can shove them back into the relevant variables here
and be on our way. */
recv_response_n(OMNI_RESPONSE_CONV_CUTOFF); /* brittle, but functional */
if (!netperf_response.content.serv_errno) {
rsr_size = omni_response->recv_buf_size;
remote_recv_size = omni_response->receive_size;
rss_size = omni_response->send_buf_size;
remote_send_size = omni_response->send_size;
rem_nodelay = omni_response->flags & OMNI_NO_DELAY;
remote_use_sendfile = omni_response->flags & OMNI_USE_SENDFILE;
remote_cpu_usage = omni_response->flags & OMNI_MEASURE_CPU;
remote_cpu_rate = omni_response->cpu_rate;
remote_send_width = omni_response->send_width;
remote_recv_width = omni_response->recv_width;
remote_socket_prio = omni_response->socket_prio;
remote_socket_tos = omni_response->socket_tos;
/* make sure that port numbers are in network order because
recv_response will have put everything into host order */
set_port_number(remote_res,
(unsigned short)omni_response->data_port);
if (debug) {
fprintf(where,"remote listen done.\n");
fprintf(where,"remote port is %u\n",get_port_number(remote_res));
fflush(where);
}
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(-1);
}
}
#ifdef WANT_DEMO
/* at some point we will have to be more clever about this, but
for now we won't */
demo_rr_setup(100);
#endif
/* if we are not a connectionless protocol, we need to connect. at
some point even if we are a connectionless protocol, we may
still want to "connect" for convenience raj 2008-01-14 */
need_to_connect = (protocol != IPPROTO_UDP) || local_connected;
/* possibly wait just a moment before actually starting - used
mainly when one is doing many many many concurrent netperf
tests */
WAIT_BEFORE_DATA_TRAFFIC();
/* Set-up the test end conditions. For tests over a
"reliable/connection-oriented" transport (eg TCP, SCTP, etc)
this can be either time or byte/transaction count based. for
unreliable transport or connection tests it can only be time
based. having said that, we rely entirely on other code to
enforce this before we even get here. raj 2008-01-08 */
/* enable a test_time of 0 to mean just keep running until
something other than alarm() generates a signal. raj
2012-02-01 */
if ((test_time) || ((test_trans == 0) && (test_bytes == 0))) {
/* The user wanted to end the test after a period of time. if
we are a recv-only test, we need to protect ourself against
the remote going poof, but we want to make sure we don't
give-up before they finish, so we will add a PAD_TIME to the
timer. if we are RR or XMIT, there should be no need for
padding */
times_up = 0;
units_remaining = 0;
if ((!no_control) &&
(NETPERF_RECV_ONLY(direction)) &&
((test_trans == 0) && (test_bytes == 0)))
pad_time = 0;
start_timer(test_time + pad_time);
}
else {
/* The tester wanted to send a number of bytes or exchange a
number of transactions. */
if (NETPERF_IS_RR(direction))
units_remaining = test_trans;
else
units_remaining = test_bytes;
times_up = 1;
}
/* grab the current time, and if necessary any starting information
for the gathering of CPU utilization at this end. */
cpu_start(local_cpu_usage);
#if defined(WANT_INTERVALS)
INTERVALS_INIT();
#endif /* WANT_INTERVALS */
#ifdef WANT_DEMO
if (demo_mode) {
demo_first_timestamp();
}
#endif
/* the "OR" here allows us to control test length by either
byte/transaction count or by timer. when the test is
byte/transaction count based the time test will always evaluate
false. when the test is controlled by time, the byte/transaction
count will always evaluate to false. when the test is finished
the whole expression will go false and we will stop sending
data. at least that is the plan :) raj 2008-01-08 */
while ((!times_up) || (units_remaining > 0)) {
/* we need to be careful about when we snap a timestamp
depending on the test parameters. this one *should* cover
everything but the burst request/response test - famous last
words of course. raj 20110111 */
if (keep_histogram) {
HIST_timestamp_start(time_hist);
}
again:
if (need_socket) {
if (connection_test)
pick_next_port_number(local_res,remote_res);
data_socket = omni_create_data_socket(local_res);
if (data_socket == INVALID_SOCKET) {
perror("netperf: send_omni: unable to create data socket");
exit(1);
}
need_socket = 0;
#if defined(__linux)
if ((protocol == IPPROTO_UDP) &&
(direction & NETPERF_XMIT)) {
enable_enobufs(data_socket);
}
#endif
}
/* only connect if and when we need to */
if (need_to_connect && !use_fastopen) {
/* assign to data_socket since connect_data_socket returns
SOCKET and not int thanks to Windows. */
ret = connect_data_socket(data_socket,remote_res,dont_give_up);
if (ret == 0) {
connected = 1;
need_to_connect = 0;
}
else if (ret == -1) {
times_up = 1;
timed_out = 1;
break;
}
else if ((ret == -2) && connection_test) {
/* transient error on a connection test means go around and
try again with another local port number */
if (debug) {
fprintf(where,"transient! transient! torpedo in the water!\n");
fflush(where);
}
close(data_socket);
connected = 0; /* probably redundant but what the heck... */
need_socket = 1;
need_to_connect = 1;
/* this will stuff the next local port number within bounds
into our local res, and then when the goto has us
allocating a new socket it will do the right thing with the
bind() call */
pick_next_port_number(local_res,remote_res);
/* yes Virginia, a goto. perhaps one day we will rewrite
the code to avoid it but for now, a goto... raj */
goto again;
}
else {
/* either this was a hard failure (-3) or a soft failure on
something other than a connection test */
perror("netperf: send_omni: connect_data_socket failed");
exit(1);
}
}
#ifdef WANT_FIRST_BURST
/* Long ago and far away, on just about any *nix, one could
avoid having multiple requests bundled into the same TCP
segment simply by setting TCP_NODELAY and perhaps not trying
to have more outstanding at one time than our guesstimate as
to the TCP congestion window. In that way one could use a
burst mode TCP_RR test as part of trying to measure maximum
packets per second (PPS) on a system or through a NIC (well,
assuming there weren't many retransmissions anyway) These
days with Linux the dominant *nix and with it having made it
virtually impossible to do any longer, it is no longer worth
it to try the application-layer backflips. So, I am removing
them. At some point we'll simply have to enhance this code
to deal with multiple connections at one time, each with just
the one transaction in flight for our PPS testing. Multiple
netperfs, each with one connection and one transaction in
flight rapidly becomes a context-switching benchmark rather
than "networking". raj 2015-04-20 */
while ((first_burst_size > 0) &&
(requests_outstanding < first_burst_size) &&
(NETPERF_IS_RR(direction)) &&
(!connection_test)) {
if (debug > 1) {
fprintf(where,
"injecting, req_outstanding %d burst %d\n",
requests_outstanding,
first_burst_size);
}
if ((ret = send_data(data_socket,
send_ring,
bytes_to_send,
(connected) ? NULL : remote_res->ai_addr,
remote_res->ai_addrlen,
protocol)) != bytes_to_send) {
/* in theory, we should never hit the end of the test in the
first burst. however, in practice I have indeed seen
some ENOBUFS happen in some aggregate tests. so we need
to be a bit more sophisticated in how we handle it. raj
20130516 */
if (ret != -2) {
perror("send_omni: initial burst data send error");
exit(-1);
}
failed_sends++;
}
else {
local_send_calls += 1;
requests_outstanding += 1;
}
/* yes, it seems a trifle odd having this *after* the send()
just above, but really this is for the next send() or
recv() call below or in the iteration of this loop, and the
first HIST_timestamp_start() call at the top of the
outermost loop will be for the first send() call here in
the burst code. clear ain't it?-) raj 20110111 */
if (keep_histogram) {
HIST_timestamp_start(time_hist);
}
}
#endif /* WANT_FIRST_BURST */
/* if we should try to send something, then by all means, let us
try to send something. */
if (direction & NETPERF_XMIT) {
ret = send_data(data_socket,
send_ring,
bytes_to_send,
(connected) ? NULL : remote_res->ai_addr,
/* if the destination above is NULL, this is ignored */
remote_res->ai_addrlen,
protocol);
/* the order of these if's will seem a triffle strange, but they
are my best guess as to order of probabilty and/or importance
to the overhead raj 2008-01-09*/
if (ret == bytes_to_send) {
/* if this is a send-only test controlled by byte count we
decrement units_remaining by the bytes sent */
if (!(direction & NETPERF_RECV) && (units_remaining > 0)) {
units_remaining -= ret;
}
bytes_sent += ret;
send_ring = send_ring->next;
local_send_calls++;
}
else if (ret == -2) {
/* what to do here -2 means a non-fatal error - probably
ENOBUFS and so our send didn't happen. in the old code for
UDP_STREAM we would just continue in the while loop. it
isn't clear that is what to do here, so we will simply
increment the failed_sends stat and fall-through. If this
is a UDP_STREAM style of test, the net effect should be the
same. if this is a UDP_RR with a really-big burst count, I
don't think we were checking for ENOBUFS there anyway and
so would have failed. Here we can just let things
slide. */
failed_sends++;
}
else if (ret == 0) {
/* was this a zero-byte send? if it was, then ostensibly we
would hit the ret == bytes_to_send case which means we'd
never get here as we are using blocking semantics */
fprintf(where,"HOW DID I GET HERE?\n");
fflush(where);
}
else if (ret == -1) {
times_up = 1;
timed_out = 1;
break;
}
else {
perror("netperf: send_omni: send_data failed");
exit(1);
}
}
#ifdef WANT_FIRST_BURST
/* it isn't clear we need to check the directions here. the
increment should be cheaper than the conditional, and it
shouldn't hurt the other directions because they'll never
look at them. famous last words of raj 2008-01-25 */
requests_outstanding += 1;
#endif
#ifdef WIN32
/* this is used so the timer thread can close the socket out
from under us, which to date is the easiest/cleanest/least
Windows-specific way I can find to force the winsock calls to
return WSAEINTR with the test is over. anything that will run
on 95 and NT and is closer to what netperf expects from Unix
signals and such would be appreciated raj 1/96 */
win_kludge_socket = data_socket;
#endif /* WIN32 */
if (direction & NETPERF_RECV) {
rret = recv_data(data_socket,
recv_ring,
bytes_to_recv,
(connected) ? NULL : (struct sockaddr *)&remote_addr,
/* if remote_addr NULL this is ignored */
&remote_addr_len,
/* if XMIT also set this is RR so waitall */
(direction & NETPERF_XMIT) ? NETPERF_WAITALL: 0,
&temp_recvs);
if (rret > 0) {
/* if this is a recv-only test controlled by byte count we
decrement the units_remaining by the bytes received */
if (!(direction & NETPERF_XMIT) && (units_remaining > 0)) {
units_remaining -= rret;
}
bytes_received += rret;
local_receive_calls += temp_recvs;
}
else if (rret == 0) {
/* is this the end of a test, just a zero-byte recv, or
something else? that is an exceedingly good question and
one for which I don't presently have a good answer, but
that won't stop me from guessing :) raj 2008-01-09 */
if (!((connection_test) || (null_message_ok))) {
/* if it is neither a connection_test nor null_message_ok it
must be the end of the test */
times_up = 1; /* ostensibly the signal handler did this */
break;
}
local_receive_calls += temp_recvs;
}
else if (rret == -1) {
/* test timed-out */
times_up = 1;
timed_out = 1;
break;
}
else if (rret == -2) {
/* we timed-out on a data receive. this is only allowed for
a UDP_RR test. we want to set things up so we start
ramping up again like we were at the beginning. if we
actually timeout it means that all has been lost. or at
least we assume so */
if (debug) {
fprintf(where,"Timeout receiving resonse from remote\n");
fflush(where);
}
#ifdef WANT_FIRST_BURST
if (first_burst_size) {
requests_outstanding = 0;
}
#endif
if (keep_histogram) {
HIST_purge(time_hist);
}
#ifdef WANT_DEMO
/* "start over" on a demo interval. we will forget about
everything that happened in the demo interval up to the
timeout and begin fresh. */
demo_reset();
#endif /* WANT_DEMO */
continue;
}
else {
/* anything else is bad */
perror("netperf: send_omni: recv_data failed");
exit(1);
}
recv_ring = recv_ring->next;
#ifdef WANT_FIRST_BURST
/* so, since we've gotten a response back, update the
bookkeeping accordingly. there is one less request
outstanding and we can put one more out there than
before. */
requests_outstanding -= 1;
#endif
}
/* if this is a connection test, we want to do some stuff about
connection close here in the test loop. raj 2008-01-08 */
if (connection_test) {
#ifdef __linux
/* so, "Linux" with autotuning likes to alter the socket buffer
sizes over the life of the connection, but only does so when
one takes the defaults at time of socket creation. if we
took those defaults, we should inquire as to what the values
ultimately became. raj 2008-01-15 */
/* however annoying having to do this might be, it really
shouldn't be done over and over again. instead we will
assume it does not change, which is fine since we would
have only reported one of them anyway. raj 20100917 */
if ((lsr_size_req < 0) && (-1 == lsr_size_end))
get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
else
lsr_size_end = lsr_size;
if ((lss_size_req < 0) && (-1 == lss_size_end))
get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
else
lss_size_end = lss_size;
#else
lsr_size_end = lsr_size;
lss_size_end = lss_size;
#endif
/* we will only make this call the one time - after the first
call, the value will be real or -1. if this is a connection
test we want to do this here because later we won't be
connected and the data may no longer be available. */
if (transport_mss == -2)
get_transport_info(data_socket,
&transport_mss,
local_res->ai_protocol);
ret = disconnect_data_socket(data_socket,
(no_control) ? 1 : 0,
1,
NULL,
0);
if (ret == 0) {
/* we will need a new connection to be established next time
around the loop. However, the next time around the loop
will already be picking the next port number */
need_to_connect = 1;
connected = 0;
need_socket = 1;
}
else if (ret == -1) {
times_up = 1;
timed_out = 1;
break;
}
else {
perror("netperf: send_omni: disconnect_data_socket failed");
exit(1);
}
}
if (keep_histogram) {
HIST_timestamp_stop_add(time_hist);
}
#ifdef WANT_DEMO
if (NETPERF_IS_RR(direction)) {
if (libfmt == 'x') {
demo_interval_tick(1);
}
else {
demo_interval_tick(req_size + rsp_size);
}
}
else if (NETPERF_XMIT_ONLY(direction)) {
demo_interval_tick(bytes_to_send);
}
else {
demo_interval_tick(rret);
}
#endif
#if defined(WANT_INTERVALS)
INTERVALS_WAIT();
#endif /* WANT_INTERVALS */
/* was this a "transaction" test? */
if (NETPERF_IS_RR(direction)) {
trans_completed++;
if (units_remaining) {
units_remaining--;
}
}
}
/* we are now, ostensibly, at the end of this iteration */
#if defined(WANT_DEMO)
/* if we were in demo mode this will ensure one final interim
result, which, naturally might be a bit early :) */
demo_interval_final();
#endif
if (transport_mss == -2)
get_transport_info(data_socket,
&transport_mss,
local_res->ai_protocol);
local_transport_retrans = get_transport_retrans(data_socket,
local_res->ai_protocol);
/* so, if we have/had a data connection, we will want to close it
now, and this will be independent of whether there is a control
connection. */
if (connected) {
#ifdef __linux
/* so, "Linux" with autotuning likes to alter the socket buffer
sizes over the life of the connection, but only does so when
one takes the defaults at time of socket creation. if we took
those defaults, we should inquire as to what the values
ultimately became. raj 2008-01-15 */
if (lsr_size_req < 0)
get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
else
lsr_size_end = lsr_size;
if (lss_size_req < 0)
get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
else
lss_size_end = lss_size;
#else
lsr_size_end = lsr_size;
lss_size_end = lss_size;
#endif
if ((desired_output_groups & OMNI_WANT_LOC_CONG) &&
(local_cong_control[0] == '\0')) {
get_transport_cong_control(data_socket,
local_res->ai_protocol,
local_cong_control,
sizeof(local_cong_control));
}
/* CHECK PARMS HERE; */
ret = disconnect_data_socket(data_socket,
1,
1,
NULL,
0);
connected = 0;
need_socket = 1;
}
else {
/* this is the UDP case at present */
ret = disconnect_data_socket(data_socket,
1,
1,
remote_res->ai_addr,
remote_res->ai_addrlen);
need_socket = 1;
lsr_size_end = lsr_size;
lss_size_end = lss_size;
}
/* 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);
/* if we timed-out, and had padded the timer, we need to subtract
the pad_time from the elapsed time on the assumption that we
were essentially idle for pad_time and just waiting for a timer
to expire on something like a UDP test. if we have not padded
the timer, pad_time will be zero. if we have not timed out
then we want to make sure we stop the timer. */
if (timed_out) {
if (debug) {
fprintf(where,"Adjusting elapsed_time by %d seconds\n",pad_time);
fflush(where);
}
elapsed_time -= (float)pad_time;
}
else {
stop_timer();
}
if (!no_control) {
/* 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_n(OMNI_RESULTS_CONV_CUTOFF);
if (!netperf_response.content.serv_errno) {
if (debug)
fprintf(where,"remote results obtained\n");
remote_cpu_method = format_cpu_method(omni_result->cpu_method);
lib_num_rem_cpus = omni_result->num_cpus;
lib_remote_cpu_stats.cpu_util = omni_result->cpu_util;
lib_remote_cpu_stats.cpu_user = omni_result->cpu_percent_user;
lib_remote_cpu_stats.cpu_system = omni_result->cpu_percent_system;
lib_remote_cpu_stats.cpu_iowait = omni_result->cpu_percent_iowait;
lib_remote_cpu_stats.cpu_irq = omni_result->cpu_percent_irq;
lib_remote_cpu_stats.cpu_swintr = omni_result->cpu_percent_swintr;
lib_remote_cpu_stats.peak_cpu_util = omni_result->peak_cpu_util;
lib_remote_cpu_stats.peak_cpu_id = omni_result->peak_cpu_id;
/* why? because some stacks want to be clever and autotune their
socket buffer sizes, which means that if we accept the defaults,
the size we get from getsockopt() at the beginning of a
connection may not be what we would get at the end of the
connection... */
rsr_size_end = omni_result->recv_buf_size;
rss_size_end = omni_result->send_buf_size;
remote_bytes_sent = (uint64_t)omni_result->bytes_sent_hi << 32;
remote_bytes_sent += omni_result->bytes_sent_lo;
remote_send_calls = omni_result->send_calls;
remote_bytes_received = (uint64_t)omni_result->bytes_received_hi << 32;
remote_bytes_received += omni_result->bytes_received_lo;
remote_receive_calls = omni_result->recv_calls;
remote_bytes_xferd = (double) remote_bytes_received +
remote_bytes_sent;
if (omni_result->recv_calls > 0)
remote_bytes_per_recv = (double) remote_bytes_received /
(double) omni_result->recv_calls;
else
remote_bytes_per_recv = 0.0;
if (omni_result->send_calls > 0)
remote_bytes_per_send = (double) remote_bytes_sent /
(double) omni_result->send_calls;
else
remote_bytes_per_send = 0.0;
remote_transport_retrans = omni_result->transport_retrans;
/* what was the congestion control? */
if (desired_output_groups & OMNI_WANT_REM_CONG) {
strncpy(remote_cong_control,
omni_result->cong_control,
sizeof(remote_cong_control));
remote_cong_control[sizeof(remote_cong_control) - 1] = '\0';
}
}
else {
Set_errno(netperf_response.content.serv_errno);
fprintf(where,
"netperf: remote error %d",
netperf_response.content.serv_errno);
perror("");
fflush(where);
exit(-1);
}
}
else {
/* when we are sending, in a no_control test, we have to
ass-u-me that everything we sent was received, otherwise, we
will report a transfer rate of zero. */
remote_bytes_xferd = (double) bytes_sent;
}
/* so, what was the end result? */
local_cpu_method = format_cpu_method(cpu_method);
if (local_send_calls > 0)
bytes_per_send = (double) bytes_sent / (double) local_send_calls;
else bytes_per_send = 0.0;
if (local_receive_calls > 0)
bytes_per_recv = (double) bytes_received / (double) local_receive_calls;
else
bytes_per_recv = 0.0;
bytes_xferd = (double) bytes_sent + bytes_received;
/* if the output format is 'x' we know the test was
request/response. if the libfmt is something else, it could be
xmit, recv or bidirectional. if we were the receiver then we
can use our byte totals even if it is
UDP/unreliable. otherwise, we use the remote totals - they
should be the same if the protocol is reliable, and if it is
unreliable then we want what was actually received */
if ('x' == libfmt)
/* it was a request/response test */
thruput = calc_thruput((double)trans_completed);
else if (NETPERF_RECV_ONLY(direction))
thruput = calc_thruput(bytes_xferd);
else
thruput = calc_thruput(remote_bytes_xferd);
if (NETPERF_IS_RR(direction)) {
float rtt_elapsed_time = elapsed_time;
#ifdef WANT_INTERVALS
/* if the test was paced, we need to subtract the time we were
sitting paced from the time we use to calculate the average
rtt_latency. Of course, won't really know how long we were
sitting unless we bracket the sit with timing calls, which
will be additional overhead affecting CPU utilization. but,
there is no such thing as a free lunch is there :) raj
20110121 */
if (interval_burst) {
rtt_elapsed_time -= (float)(interval_wait_microseconds / 1000000.0);
}
#endif /* WANT_INTERVALS */
if (!connection_test) {
/* calculate the round trip latency, using the transaction rate
whether or not the user was asking for thruput to be in 'x'
units please... however... a connection_test only ever has
one transaction in flight at one time */
rtt_latency =
(((double)1.0/(trans_completed/rtt_elapsed_time)) *
(double)1000000.0) *
(double) (1 + ((first_burst_size > 0) ? first_burst_size : 0));
}
else {
rtt_latency = ((double)1.0/(trans_completed/rtt_elapsed_time)) *
(double)1000000.0;
}
tmpfmt = libfmt;
libfmt = 'x';
transaction_rate = calc_thruput((double)trans_completed);
libfmt = tmpfmt;
}
/* ok, time to possibly calculate cpu util and/or service demand */
if (local_cpu_usage) {
local_cpu_utilization = calc_cpu_util(elapsed_time);
/* we need to decide what to feed the service demand beast,
which will, ultimately, depend on what sort of test it is and
whether or not the user asked for something specific - as in
per KB even on a TCP_RR test if it is being (ab)used as a
bidirectional bulk-transfer test. raj 2008-01-14 */
local_service_demand =
calc_service_demand_fmt(('x' == libfmt) ? (double)trans_completed: bytes_xferd,
0.0,
0.0,
0);
}
else {
local_cpu_utilization = (float) -1.0;
local_service_demand = (float) -1.0;
}
if (remote_cpu_usage) {
remote_cpu_utilization = omni_result->cpu_util;
remote_service_demand =
calc_service_demand_fmt(('x' == libfmt) ? (double) trans_completed: bytes_xferd,
0.0,
remote_cpu_utilization,
omni_result->num_cpus);
}
else {
remote_cpu_utilization = (float) -1.0;
remote_service_demand = (float) -1.0;
}
/* time to calculate our confidence */
calculate_confidence(confidence_iteration,
elapsed_time,
thruput,
local_cpu_utilization,
remote_cpu_utilization,
local_service_demand,
remote_service_demand);
/* this this is the end of the confidence while loop? */
confidence_iteration++;
}
/* we end with confidence_iteration one larger than the number of
iterations. if we weren't doing confidence intervals this will
still be reported as one */
confidence_iteration--;
#if defined(WANT_INTERVALS)
#ifdef WIN32
stop_itimer();
#endif
#endif /* WANT_INTERVALS */
/* at some point we may want to actually display some results :) */
retrieve_confident_values(&elapsed_time,
&thruput,
&local_cpu_utilization,
&remote_cpu_utilization,
&local_service_demand,
&remote_service_demand);
/* a kludge for omni printing because I don't know how to tell that
something is a float vs a double in my_snprintf() given what it
is passed and I'm not ready to force all the netlib.c stuff to
use doubles rather than floats. help there would be
appreciated. raj 2008-01-28 */
elapsed_time_double = (double) elapsed_time;
local_service_demand_double = (double)local_service_demand;
remote_service_demand_double = (double)remote_service_demand;
if ('x' == libfmt) sd_str = "usec/Tran";
else sd_str = "usec/KB";
if (iteration_max > 1) {
result_confid_pct = get_result_confid();
loc_cpu_confid_pct = get_loc_cpu_confid();
rem_cpu_confid_pct = get_rem_cpu_confid();
interval_pct = interval * 100.0;
}
/* at some point we need to average these during a confidence
interval run, and when we do do that, we need to make sure we
restore the value of libfmt correctly */
tmpfmt = libfmt;
if ('x' == libfmt) {
libfmt = 'm';
}
local_send_thruput = calc_thruput((double)bytes_sent);
local_recv_thruput = calc_thruput((double)bytes_received);
remote_send_thruput = calc_thruput((double)remote_bytes_sent);
remote_recv_thruput = calc_thruput((double)remote_bytes_received);
libfmt = tmpfmt;
/* were we tracking possibly expensive statistics? */
if (keep_statistics) {
HIST_get_stats(time_hist,
&min_latency,
&max_latency,
&mean_latency,
&stddev_latency);
p50_latency = HIST_get_percentile(time_hist, 0.50);
p90_latency = HIST_get_percentile(time_hist, 0.90);
p99_latency = HIST_get_percentile(time_hist, 0.99);
}
/* if we are running a legacy test we do not do the nifty new omni
output stuff */
if (!legacy) {
print_omni();
}
#if defined(DEBUG_OMNI_OUTPUT)
{
/* just something quick to sanity check the output selectors. this
should be gone for "production" :) */
int i;
print_omni_init();
output_list[0][1] = OUTPUT_END;
for (i = OUTPUT_NONE; i < NETPERF_OUTPUT_MAX; i++) {
output_list[0][0] = i;
print_omni_csv();
}
}
#endif
/* likely as not we are going to do something slightly different here */
if ((verbosity > 1) && (!legacy)) {
#ifdef WANT_HISTOGRAM
fprintf(where,"\nHistogram of ");
if (NETPERF_RECV_ONLY(direction))
fprintf(where,"recv");
if (NETPERF_XMIT_ONLY(direction))
fprintf(where,"send");
if (NETPERF_IS_RR(direction)) {
if (connection_test) {
if (NETPERF_CC(direction)) {
fprintf(where,"connect/close");
}
else {
fprintf(where,"connect/request/response/close");
}
}
else {
fprintf(where,"request/response");
}
}
fprintf(where," times\n");
HIST_report(time_hist);
fflush(where);
#endif /* WANT_HISTOGRAM */
}
}
void
send_omni(char remote_host[])
{
char name_buf[32];
snprintf(name_buf,sizeof(name_buf),"OMNI %s TEST",direction_str);
name_buf[31] = '\0';
send_omni_inner(remote_host, 0, name_buf);
}
#if defined(WIN32)
#if !defined(InetNtop)
/* +*+ Why isn't this in the winsock headers yet? */
const char *
inet_ntop(int af, const void *src, char *dst, size_t size);
#endif
#endif
static void
set_hostname_and_port_2(void *addr, char *hostname, char *portstr, int family, int port)
{
inet_ntop(family, addr, hostname, BUFSIZ);
sprintf(portstr, "%u", port);
}
/* the name is something of a misnomer since this test could send, or
receive, or both, but it matches the historical netperf routine
naming convention for what runs in the netserver context. */
void
recv_omni()
{
struct addrinfo *local_res;
char local_name[BUFSIZ];
char port_buffer[PORTBUFSIZE];
struct sockaddr_storage myaddr_in, peeraddr_in;
int peeraddr_set = 0;
SOCKET s_listen, data_socket;
netperf_socklen_t addrlen;
struct ring_elt *send_ring;
struct ring_elt *recv_ring;
int timed_out = 0;
int pad_time = 0;
int need_to_connect = 0;
int need_to_accept;
int connected;
int ret;
uint32_t temp_recvs;
struct omni_request_struct *omni_request;
struct omni_response_struct *omni_response;
struct omni_results_struct *omni_results;
omni_request =
(struct omni_request_struct *)netperf_request.content.test_specific_data;
omni_response =
(struct omni_response_struct *)netperf_response.content.test_specific_data;
omni_results =
(struct omni_results_struct *)netperf_response.content.test_specific_data;
if (debug) {
fprintf(where,"netserver: %s: entered...\n",__FUNCTION__);
fflush(where);
}
/* netserver has no good way of knowing where the conversion cutoff
point is, so we have to fix it after the fact */
fixup_request_n(OMNI_REQUEST_CONV_CUTOFF);
/* thus fixed-up, we can extract the requested congestion control
algorithm */
strncpy(local_cong_control_req,
omni_request->cong_control,
sizeof(local_cong_control_req));
/* based on what we have been told by the remote netperf, we want to
setup our endpoint for the "data connection" and let the remote
netperf know the situation. */
if (debug) {
fprintf(where,"%s: setting the response type...\n",__FUNCTION__);
fflush(where);
}
netperf_response.content.response_type = OMNI_RESPONSE;
if (debug) {
fprintf(where,"%s: the response type is set...\n",__FUNCTION__);
fflush(where);
}
/* Grab a socket to listen on, and then listen on it. */
if (debug) {
fprintf(where,"%s: grabbing a socket...\n",__FUNCTION__);
fflush(where);
}
/* create_data_socket expects to find some things in the global
variables, so set the globals based on the values in the request.
once the socket has been created, we will set the response values
based on the updated value of those globals. raj 7/94 */
lss_size_req = omni_request->send_buf_size;
lsr_size_req = omni_request->recv_buf_size;
loc_nodelay = (omni_request->flags) & OMNI_NO_DELAY;
loc_rcvavoid = omni_request->so_rcvavoid;
loc_sndavoid = omni_request->so_sndavoid;
routing_allowed = (omni_request->flags) & OMNI_ROUTING_ALLOWED;
want_keepalive = (omni_request->flags) & OMNI_WANT_KEEPALIVE;
local_socket_prio = omni_request->socket_prio;
local_socket_tos = omni_request->socket_tos;
want_defer_accept = omni_request->flags & OMNI_WANT_DEFER_ACCEPT;
#ifdef WANT_INTERVALS
interval_usecs = omni_request->interval_usecs;
interval_wate = interval_usecs / 1000;
interval_burst = omni_request->interval_burst;
#else
interval_usecs = 0;
interval_wate = 1;
interval_burst = 0;
#endif
connection_test = omni_request->flags & OMNI_CONNECT_TEST;
#ifdef TCP_FASTOPEN
use_fastopen = omni_request->flags & OMNI_FASTOPEN;
#endif
direction = omni_request->direction;
use_pktinfo = (omni_request->flags) & OMNI_USE_PKTINFO;
/* let's be quite certain the fill file string is null terminated */
omni_request->fill_file[sizeof(omni_request->fill_file) - 1] = '\0';
strncpy(local_fill_file,
omni_request->fill_file,
sizeof(local_fill_file));
/* kludgy, because I have no way at present to say how many bytes
needed to be swapped around for the request from which this is
pulled, and it is probably all wrong for IPv6 :( */
switch (nf_to_af(omni_request->ipfamily)) {
case AF_INET6:
/* yes indeed it is, do nothing, bz */
break;
case AF_INET:
default:
for (ret=0; ret < 4; ret++) {
omni_request->netserver_ip[ret] = htonl(omni_request->netserver_ip[ret]);
omni_request->netperf_ip[ret] = htonl(omni_request->netperf_ip[ret]);
}
break;
}
set_hostname_and_port_2(omni_request->netserver_ip,
local_name,
port_buffer,
nf_to_af(omni_request->ipfamily),
omni_request->data_port);
local_res = complete_addrinfo(local_name,
local_name,
port_buffer,
nf_to_af(omni_request->ipfamily),
nst_to_hst(omni_request->socket_type),
omni_request->protocol,
0);
s_listen = omni_create_data_socket(local_res);
if (s_listen == INVALID_SOCKET) {
netperf_response.content.serv_errno = errno;
send_response();
if (debug) {
fprintf(where,"could not create data socket\n");
fflush(where);
}
exit(-1);
}
/* We now alter the message_ptr variables to be at the desired */
/* alignments with the desired offsets. */
if (debug) {
fprintf(where,
"recv_omni: requested recv alignment of %d offset %d\n"
"recv_omni: requested send alignment of %d offset %d\n",
omni_request->recv_alignment,
omni_request->recv_offset,
omni_request->send_alignment,
omni_request->send_offset);
fflush(where);
}
omni_response->send_size = omni_request->send_size;
omni_response->send_width = omni_request->send_width;
omni_response->socket_prio = local_socket_prio;
omni_response->socket_tos = local_socket_tos;
if (omni_request->direction & NETPERF_XMIT) {
#ifdef fo
/* do we need to set multicast ttl? */
if (is_multicast_addr(remote_res)) {
/* yes, s_listen - for a UDP test we will be copying it to
data_socket but that hasn't happened yet. raj 20100315 */
set_multicast_ttl(s_listen);
}
#endif
if (omni_request->response_size > 0) {
/* request/response_test */
bytes_to_send = omni_request->response_size;
if (omni_request->send_width == 0) send_width = 1;
else send_width = omni_request->send_width;
}
else {
if (omni_request->send_size == -1) {
bytes_to_send = choose_send_size(lss_size,omni_request->protocol);
}
else bytes_to_send = omni_request->send_size;
/* set the send_width */
if (omni_request->send_width == 0) {
send_width = (lss_size/bytes_to_send) + 1;
if (send_width == 1) send_width++;
}
else
send_width = omni_request->send_width;
}
send_ring = allocate_buffer_ring(send_width,
bytes_to_send,
omni_request->send_alignment,
omni_request->send_offset);
omni_response->send_width = send_width;
omni_response->send_size = bytes_to_send;
}
omni_response->receive_size = omni_request->receive_size;
omni_response->recv_width = omni_request->recv_width;
if (omni_request->direction & NETPERF_RECV) {
/* do we need to join a multicast group? */
if (is_multicast_addr(local_res)) {
/* yes, s_listen - for a UDP test we will be copying it to
data_socket but that hasn't happened yet. raj 20100315 */
join_multicast_addr(s_listen, local_res);
}
if (omni_request->request_size > 0) {
/* request/response test */
bytes_to_recv = omni_request->request_size;
if (omni_request->recv_width == 0) recv_width = 1;
else recv_width = omni_request->recv_width;
}
else {
if (omni_request->receive_size == -1) {
if (lsr_size > 0) bytes_to_recv = lsr_size;
else bytes_to_recv = 4096;
}
else {
bytes_to_recv = omni_request->receive_size;
}
/* set the recv_width */
if (omni_request->recv_width == 0) {
recv_width = (lsr_size/bytes_to_recv) + 1;
if (recv_width == 1) recv_width++;
}
else
recv_width = omni_request->recv_width;
}
recv_ring = allocate_buffer_ring(recv_width,
bytes_to_recv,
omni_request->recv_alignment,
omni_request->recv_offset);
omni_response->receive_size = bytes_to_recv;
omni_response->recv_width = recv_width;
}
#ifdef WIN32
/* The test timer can fire during operations on the listening socket,
so to make the start_timer below work we have to move
it to close s_listen while we are blocked on accept. */
win_kludge_socket2 = s_listen;
#endif
need_to_accept = (omni_request->protocol != IPPROTO_UDP);
/* we need to hang a listen for everything that needs at least one
accept. the age-old constant of 5 is probably OK for our purposes
but does not necessarily represent best practice */
if (need_to_accept) {
int backlog = 5;
#ifdef TCP_FASTOPEN
/* one of these days I will have to go find-out what the backlog
is supposed to be here. until then, I'll just set it to five
like the listen() call does - it is classic, and was what was
used in the online example I found */
if (use_fastopen &&
(setsockopt(s_listen,IPPROTO_TCP, TCP_FASTOPEN, &backlog, sizeof(backlog)) ==
SOCKET_ERROR)) {
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
if (debug) {
fprintf(where,"netperfserver: %s could not fastopen\n",__FUNCTION__);
fflush(where);
}
exit(1);
}
#endif /* TCP_FASTOPEN */
#ifdef TCP_DEFER_ACCEPT
if (want_defer_accept &&
(setsockopt(s_listen, IPPROTO_TCP, TCP_DEFER_ACCEPT, &backlog, sizeof(backlog)) == SOCKET_ERROR)) {
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
if (debug) {
fprintf(where,
"netperfserver: %s could not defer accept\n",__FUNCTION__);
fflush(where);
}
exit(1);
}
#endif /* TCP_DEFER_ACCEPT */
if (listen(s_listen, backlog) == SOCKET_ERROR) {
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
if (debug) {
fprintf(where,"netperfserver: %s could not listen\n",__FUNCTION__);
fflush(where);
}
exit(1);
}
}
/* now get the port number assigned by the system */
addrlen = sizeof(myaddr_in);
if (getsockname(s_listen,
(struct sockaddr *)&myaddr_in,
&addrlen) == SOCKET_ERROR){
netperf_response.content.serv_errno = errno;
close(s_listen);
send_response();
if (debug) {
fprintf(where,"could not getsockname\n");
fflush(where);
}
exit(-1);
}
/* Now myaddr_in contains the port and the internet address this is
returned to the sender also implicitly telling the sender that
the socket buffer sizing has been done. likely as not, the IP
address will be the wildcard - so we only really need to extract
the port number. since send_response is going to call htonl on
all the fields, we want to initially put the port number in there
in host order. */
omni_response->data_port =
(int) ntohs(((struct sockaddr_in *)&myaddr_in)->sin_port);
if (debug) {
fprintf(where,"telling the remote to call me at %d\n",
omni_response->data_port);
fflush(where);
}
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. */
omni_response->cpu_rate = (float)0.0; /* assume no cpu */
omni_response->flags &= ~OMNI_MEASURE_CPU;
if (omni_request->flags & OMNI_MEASURE_CPU) {
omni_response->flags |= OMNI_MEASURE_CPU;
omni_response->cpu_rate =
calibrate_local_cpu(omni_request->cpu_rate);
}
/* before we send the response back to the initiator, pull some of */
/* the socket parms from the globals */
omni_response->send_buf_size = lss_size;
omni_response->recv_buf_size = lsr_size;
if (loc_nodelay)
omni_response->flags |= OMNI_NO_DELAY;
else
omni_response->flags &= ~OMNI_NO_DELAY;
omni_response->so_rcvavoid = loc_rcvavoid;
omni_response->so_sndavoid = loc_sndavoid;
omni_response->interval_usecs = interval_usecs;
omni_response->interval_burst = interval_burst;
send_response_n(OMNI_RESPONSE_CONV_CUTOFF); /* brittle, but functional */
local_send_calls = 0;
local_receive_calls = 0;
addrlen = sizeof(peeraddr_in);
memset(&peeraddr_in,0,sizeof(peeraddr_in));
/* Now it's time to start receiving data on the connection. We will */
/* first grab the apropriate counters and then start grabbing. */
cpu_start(omni_request->flags & OMNI_MEASURE_CPU);
/* if the test is timed, set a timer of suitable length. if the
test is by byte/transaction count, we don't need a timer - or
rather we rely on the netperf to only ask us to do transaction
counts over "reliable" protocols. perhaps at some point we
should add a check herebouts to verify that... */
if (omni_request->test_length >= 0) {
times_up = 0;
units_remaining = 0;
test_time=omni_request->test_length;
/* if we are the sender and only sending, then we don't need/want
the padding, otherwise, we need the padding */
if (!(NETPERF_XMIT_ONLY(omni_request->direction)) &&
(omni_request->test_length > 0))
pad_time = PAD_TIME;
start_timer(omni_request->test_length + pad_time);
}
else {
times_up = 1;
units_remaining = omni_request->test_length * -1;
}
#if defined(WANT_INTERVALS)
INTERVALS_INIT();
#endif /* WANT_INTERVALS */
trans_completed = 0;
bytes_sent = 0;
bytes_received = 0;
connected = 0;
while ((!times_up) || (units_remaining > 0)) {
if (need_to_accept) {
/* accept a connection from the remote */
#ifdef WIN32
/* The test timer will probably fire during this accept,
so to make the start_timer above work we have to move
it to close s_listen while we are blocked on accept. */
win_kludge_socket = s_listen;
#endif
if ((data_socket=accept(s_listen,
(struct sockaddr *)&peeraddr_in,
&addrlen)) == INVALID_SOCKET) {
if (errno == EINTR) {
/* the timer popped */
times_up = 1; /* ostensibly the signal hander dealt with this?*/
timed_out = 1;
break;
}
netperf_response.content.serv_errno = errno;
send_response();
fprintf(where,"%s: accept: errno = %d\n",__FUNCTION__,errno);
fflush(where);
close(s_listen);
exit(-1);
}
if (debug) {
fprintf(where,"%s: accepted data connection.\n",__FUNCTION__);
fflush(where);
}
need_to_accept = 0;
connected = 1;
#ifdef KLUDGE_SOCKET_OPTIONS
/* this is for those systems which *INCORRECTLY* fail to pass
attributes across an accept() call. Including this goes
against my better judgement :( raj 11/95 */
kludge_socket_options(data_socket);
#endif /* KLUDGE_SOCKET_OPTIONS */
}
else {
/* I wonder if duping would be better here? we also need to set
peeraddr_in so we can send to netperf if this isn't a
request/response test or if we are going to connect() the
socket, but we only need to do it once. */
if ((omni_request->protocol == IPPROTO_UDP) &&
(!peeraddr_set)) {
peeraddr_set = 1;
data_socket = s_listen;
set_sockaddr_family_addr_port(&peeraddr_in,
nf_to_af(omni_request->ipfamily),
omni_request->netperf_ip,
omni_request->netperf_port);
}
}
#ifdef WIN32
/* this is used so the timer thread can close the socket out from
under us, which to date is the easiest/cleanest/least
Windows-specific way I can find to force the winsock calls to
return WSAEINTR with the test is over. anything that will run on
95 and NT and is closer to what netperf expects from Unix signals
and such would be appreciated raj 1/96 */
win_kludge_socket = data_socket;
#endif /* WIN32 */
/* in recv_omni, we check recv first, and _then_ send, otherwise,
a request/response test will be all messed-up :) and that then
is why there are two routines to rule them all rather than just
one :) */
if ((omni_request->direction & NETPERF_RECV) &&
((!times_up) || (units_remaining > 0))) {
ret = recv_data(data_socket,
recv_ring,
bytes_to_recv,
(connected) ? NULL : (struct sockaddr *)&peeraddr_in,
&addrlen,
/* if XMIT also, then this is RR test so waitall */
(direction & NETPERF_XMIT) ? NETPERF_WAITALL: 0,
&temp_recvs);
if (ret > 0) {
/* if this is a recv-only test controlled by byte count we
decrement the units_remaining by the bytes received */
if (!(direction & NETPERF_XMIT) && (units_remaining > 0)) {
units_remaining -= ret;
}
bytes_received += ret;
local_receive_calls += temp_recvs;
}
else if (ret == 0) {
/* is this the end of a test, just a zero-byte recv, or
something else? that is an exceedingly good question and
one for which I don't presently have a good answer, but
that won't stop me from guessing :) raj 2008-01-09 */
if (!((connection_test) || (null_message_ok))) {
/* if it is neither a connection_test nor null_message_ok it
must be the end of the test */
times_up = 1;
break;
}
local_receive_calls += temp_recvs;
}
else if (ret == -1) {
/* test timed-out */
times_up = 1;
timed_out = 1;
break;
}
else {
/* presently at least, -2 and -3 are equally bad on recv */
/* we need a response message here for the control connection
before we exit! */
netperf_response.content.serv_errno = errno;
send_response();
exit(-1);
}
recv_ring = recv_ring->next;
}
/* if we should try to send something, then by all means, let us
try to send something. */
if ((omni_request->direction & NETPERF_XMIT) &&
((!times_up) || (units_remaining > 0))) {
/* there used to be some code here looking sched_yield() until
there was no more queued, unsent data on the socket but
frankly, I've no idea what that was all about so I have
removed it. It may have been part of a kludge to try to avoid
coalescing requests and responses */
if (omni_request->protocol == IPPROTO_UDP && need_to_connect &&
!connected) {
if (connect(data_socket,
(struct sockaddr*)&peeraddr_in,
addrlen) == INVALID_SOCKET) {
netperf_response.content.serv_errno = errno;
send_response();
close(data_socket);
exit(-1);
}
connected = 1;
}
ret = send_data(data_socket,
send_ring,
bytes_to_send,
(connected) ? NULL : (struct sockaddr *)&peeraddr_in,
addrlen,
omni_request->protocol);
/* the order of these if's will seem a triffle strange, but they
are my best guess as to order of probabilty and/or importance
to the overhead raj 2008-01-09*/
if (ret == bytes_to_send) {
/* if this is a send-only test controlled by byte count we
decrement units_remaining by the bytes sent */
if (!(direction & NETPERF_RECV) && (units_remaining > 0)) {
units_remaining -= ret;
}
bytes_sent += ret;
send_ring = send_ring->next;
local_send_calls++;
}
else if (ret == -2) {
/* what to do here -2 means a non-fatal error - probably
ENOBUFS and so our send didn't happen. in the old code for
UDP_STREAM we would just continue in the while loop. it
isn't clear that is what to do here, so we will simply
increment the failed_sends stat and fall-through. If this
is a UDP_STREAM style of test, the net effect should be the
same. if this is a UDP_RR with a really-big burst count, I
don't think we were checking for ENOBUFS there anyway and
so would have failed. Here we can just let things
slide. */
failed_sends++;
}
else if (ret == 0) {
/* was this a zero-byte send? if it was, then ostensibly we
would hit the ret == bytes_to_send case which means we'd
never get here as we are using blocking semantics */
}
else if (ret == -1) {
times_up = 1;
timed_out = 1;
break;
}
else {
/* we need a response message back to netperf here before we
exit */
/* NEED RESPONSE; */
netperf_response.content.serv_errno = errno;
send_response();
exit(-1);
}
}
if (connection_test) {
#ifdef __linux
/* so, "Linux" with autotuning likes to alter the socket buffer
sizes over the life of the connection, but only does so when
one takes the defaults at time of socket creation. if we
took those defaults, we should inquire as to what the values
ultimately became. raj 2008-01-15 */
/* but as annoying as it is to have to make these calls, don't
penalize linux by calling them over and over again. instead
we will simply ass-u-me that it will become the same value
over and over again. raj 20100917 */
if ((lsr_size_req < 0) && (-1 == lsr_size_end))
get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
else
lsr_size_end = lsr_size;
if ((lss_size_req < 0) && (-1 == lss_size_end))
get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
else
lss_size_end = lss_size;
#else
lsr_size_end = lsr_size;
lss_size_end = lss_size;
#endif
ret = close_data_socket(data_socket,NULL,0,omni_request->protocol);
if (ret == -1) {
times_up = 1;
timed_out = 1;
break;
}
else if (ret < 0) {
netperf_response.content.serv_errno = errno;
send_response();
perror("netperf: recv_omni: close_data_socket failed");
fflush(where);
exit(-1);
}
/* we will need a new connection to be established */
need_to_accept = 1;
connected = 0;
}
#if defined(WANT_INTERVALS)
INTERVALS_WAIT();
#endif /* WANT_INTERVALS */
/* was this a "transaction" test? don't for get that a TCP_CC
style test will have no xmit or recv :) so, we check for either
both XMIT and RECV set, or neither XMIT nor RECV set */
if (NETPERF_IS_RR(omni_request->direction)) {
trans_completed++;
if (units_remaining) {
units_remaining--;
}
}
}
/* The current iteration loop now exits due to timeout or unit count
being reached */
stop_timer();
cpu_stop(omni_request->flags & OMNI_MEASURE_CPU,&elapsed_time);
close(s_listen);
#if defined(WANT_INTERVALS)
#ifdef WIN32
stop_itimer();
#endif
#endif /* WANT_INTERVALS */
if (timed_out) {
/* we ended the test by time, which may have been PAD_TIME seconds
longer than we wanted to run. so, we want to subtract pad_time
from the elapsed_time. if we didn't pad the timer pad_time will
be 0 so we can just subtract it anyway :) */
if (debug) {
fprintf(where,"Adjusting elapsed time by %d seconds\n",pad_time);
fflush(where);
}
elapsed_time -= pad_time;
}
remote_transport_retrans = get_transport_retrans(data_socket,
omni_request->protocol);
if (connected) {
#ifdef __linux
/* so, "Linux" with autotuning likes to alter the socket buffer
sizes over the life of the connection, but only does so when
one takes the defaults at time of socket creation. if we took
those defaults, we should inquire as to what the values
ultimately became. raj 2008-01-15 */
if (lsr_size_req < 0)
get_sock_buffer(data_socket, RECV_BUFFER, &lsr_size_end);
else
lsr_size_end = lsr_size;
if (lss_size_req < 0)
get_sock_buffer(data_socket, SEND_BUFFER, &lss_size_end);
else
lss_size_end = lss_size;
#else
lsr_size_end = lsr_size;
lss_size_end = lss_size;
#endif
if (omni_request->flags & OMNI_WANT_REM_CONG) {
get_transport_cong_control(data_socket,
local_res->ai_protocol,
omni_results->cong_control,
sizeof(omni_results->cong_control));
}
else {
strncpy(omni_results->cong_control,"",sizeof(omni_results->cong_control));
}
close_data_socket(data_socket,NULL,0,omni_request->protocol);
}
else {
close_data_socket(data_socket,(struct sockaddr *)&peeraddr_in,addrlen,omni_request->protocol);
lsr_size_end = lsr_size;
lss_size_end = lss_size;
}
/* send the results to the sender */
omni_results->send_calls = (uint32_t) local_send_calls;
omni_results->bytes_received_lo = bytes_received & 0x00000000FFFFFFFFULL;
omni_results->bytes_received_hi = (bytes_received & 0xFFFFFFFF00000000ULL) >> 32;
omni_results->recv_buf_size = lsr_size_end;
omni_results->recv_calls = (uint32_t) local_receive_calls;
omni_results->bytes_sent_lo = bytes_sent & 0x00000000FFFFFFFFULL;
omni_results->bytes_sent_hi = (bytes_sent & 0xFFFFFFFF00000000ULL) >> 32;
omni_results->send_buf_size = lss_size_end;
omni_results->trans_received = (uint32_t) trans_completed;
omni_results->elapsed_time = elapsed_time;
omni_results->transport_retrans = remote_transport_retrans;
omni_results->cpu_method = cpu_method;
omni_results->num_cpus = lib_num_loc_cpus;
if (omni_request->flags & OMNI_MEASURE_CPU) {
omni_results->cpu_util = calc_cpu_util(elapsed_time);
omni_results->cpu_percent_user = lib_local_cpu_stats.cpu_user;
omni_results->cpu_percent_system = lib_local_cpu_stats.cpu_system;
omni_results->cpu_percent_iowait = lib_local_cpu_stats.cpu_iowait;
omni_results->cpu_percent_irq = lib_local_cpu_stats.cpu_irq;
omni_results->cpu_percent_swintr = lib_local_cpu_stats.cpu_swintr;
omni_results->peak_cpu_util = lib_local_cpu_stats.peak_cpu_util;
omni_results->peak_cpu_id = lib_local_cpu_stats.peak_cpu_id;
}
#if defined(WANT_INTERVALS)
#ifdef WIN32
stop_itimer();
#endif
#endif /* WANT_INTERVALS */
if (debug) {
fprintf(where,
"%s: test complete, sending results.\n",
__FUNCTION__);
fflush(where);
}
send_response_n(OMNI_RESULTS_CONV_CUTOFF);
}
#ifdef WANT_MIGRATION
void
send_tcp_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 %s\n";
char *tput_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f %s\n";
char *cpu_title = "\
Recv Send Send Utilization Service Demand\n\
Socket Socket Message Elapsed Send Recv Send Recv\n\
Size Size Size Time Throughput local remote local remote\n\
bytes bytes bytes secs. %-8.8s/s %% %c %% %c us/KB us/KB\n\n";
char *cpu_fmt_0 =
"%6.3f %c %s\n";
char *cpu_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f %-6.2f %-6.2f %-6.3f %-6.3f %s\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"PRId64" %6.2f %6"PRId64" %6.2f %6"PRId64"\n";
char *ksink_fmt2 = "\n\
Maximum\n\
Segment\n\
Size (bytes)\n\
%6d\n";
send_omni_inner(remote_host, legacy, "MIGRATED TCP STREAM TEST");
if (legacy) {
/* We are now ready to print all the information, but only if we
are truly acting as a legacy test. If the user has specified
zero-level verbosity, we will just print the local service
demand, or the remote service demand. If the user has requested
verbosity level 1, he will get the basic "streamperf"
numbers. If the user has specified a verbosity of greater than
1, we will display a veritable plethora of background
information from outside of this block as it it not
cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
format_units(),
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long was the test */
thruput, /* what was the xfer rate */
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand, /* remote service demand */
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long did it take */
thruput, /* how fast did it go */
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
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 */
/* TCP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
/* this stuff needs to be worked-out in the presence of confidence */
/* intervals and multiple iterations of the test... raj 11/94 */
fprintf(where,
ksink_fmt,
"Bytes",
"Bytes",
"Bytes",
local_send_align,
remote_recv_align,
local_send_offset,
remote_recv_offset,
bytes_sent,
bytes_sent / (double)local_send_calls,
local_send_calls,
bytes_sent / (double)remote_receive_calls,
remote_receive_calls);
fprintf(where,
ksink_fmt2,
transport_mss);
#ifdef WANT_HISTOGRAM
fprintf(where,"\n\nHistogram of time spent in send() call.\n");
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
fflush(where);
}
}
}
void
send_tcp_maerts(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 %s\n";
char *tput_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f %s\n";
char *cpu_title = "\
Recv Send Send Utilization Service Demand\n\
Socket Socket Message Elapsed Recv Send Recv Send\n\
Size Size Size Time Throughput local remote local remote\n\
bytes bytes bytes secs. %-8.8s/s %% %c %% %c us/KB us/KB\n\n";
char *cpu_fmt_0 =
"%6.3f %c %s\n";
char *cpu_fmt_1 =
"%6d %6d %6d %-6.2f %7.2f %-6.2f %-6.2f %-6.3f %-6.3f %s\n";
char *ksink_fmt = "\n\
Alignment Offset %-8.8s %-8.8s Recvs %-8.8s Sends\n\
Local Remote Local Remote Xfered Per Per\n\
Recv Send Recv Send Recv (avg) Send (avg)\n\
%5d %5d %5d %5d %6"PRId64" %6.2f %6d %6.2f %6d\n";
char *ksink_fmt2 = "\n\
Maximum\n\
Segment\n\
Size (bytes)\n\
%6d\n";
send_omni_inner(remote_host, legacy, "MIGRATED TCP MAERTS TEST");
/* We are now ready to print all the information, but only if we are
truly acting as a leacy test. If the user has specified
zero-level verbosity, we will just print the local service
demand, or the remote service demand. If the user has requested
verbosity level 1, he will get the basic "streamperf" numbers. If
the user has specified a verbosity of greater than 1, we will
display a veritable plethora of background information from
outside of this block as it it not cpu_measurement
specific... */
if (legacy) {
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
format_units(),
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1, /* the format string */
rsr_size, /* remote recvbuf size */
lss_size, /* local sendbuf size */
remote_send_size, /* how large were the recvs */
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 */
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1, /* the format string */
lsr_size, /* local recvbuf size */
rss_size, /* remot sendbuf size */
remote_send_size, /* how large were the recvs */
elapsed_time, /* how long did it take */
thruput, /* how fast did it go */
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
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 */
/* TCP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
/* this stuff needs to be worked-out in the presence of confidence */
/* intervals and multiple iterations of the test... raj 11/94 */
fprintf(where,
ksink_fmt,
"Bytes",
"Bytes",
"Bytes",
local_recv_align,
remote_recv_align,
local_recv_offset,
remote_recv_offset,
bytes_received,
bytes_received / (double)local_receive_calls,
local_receive_calls,
remote_bytes_sent / (double)remote_send_calls,
remote_send_calls);
fprintf(where,
ksink_fmt2,
transport_mss);
#ifdef WANT_HISTOGRAM
fprintf(where,"\n\nHistogram of time spent in recv() call.\n");
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
fflush(where);
}
}
}
void
send_tcp_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_title_band = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed \n\
Send Recv Size Size Time Throughput \n\
bytes Bytes bytes bytes secs. %s/sec \n\n";
char *tput_fmt_0 =
"%7.2f %s\n";
char *tput_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %7.2f %s\n";
char *tput_fmt_1_line_2 = "\
%-6d %-6d\n";
char *cpu_title = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Trans. CPU CPU S.dem S.dem\n\
Send Recv Size Size Time Rate local remote local remote\n\
bytes bytes bytes bytes secs. per sec %% %c %% %c us/Tr us/Tr\n\n";
char *cpu_title_tput = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Tput CPU CPU S.dem S.dem\n\
Send Recv Size Size Time %-8.8s local remote local remote\n\
bytes bytes bytes bytes secs. per sec %% %c %% %c us/KB us/KB\n\n";
char *cpu_title_latency = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Latency CPU CPU S.dem S.dem\n\
Send Recv Size Size Time usecs local remote local remote\n\
bytes bytes bytes bytes secs. per tran %% %c %% %c us/Tr us/Tr\n\n";
char *cpu_fmt_0 =
"%6.3f %c %s\n";
char *cpu_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %-6.2f %-6.2f %-6.2f %-6.3f %-6.3f %s\n";
char *cpu_fmt_1_line_2 = "\
%-6d %-6d\n";
char *ksink_fmt = "\
Alignment Offset RoundTrip Trans Throughput\n\
Local Remote Local Remote Latency Rate %-8.8s/s\n\
Send Recv Send Recv usec/Tran per sec Outbound Inbound\n\
%5d %5d %5d %5d %-6.3f %-6.3f %-6.3f %-6.3f\n";
send_omni_inner(remote_host, legacy, "MIGRATED TCP REQUEST/RESPONSE TEST");
if (legacy) {
/* We are now ready to print all the information. If the user has
specified zero-level verbosity, we will just print the local
service demand, or the remote service demand. If the user has
requested verbosity level 1, he will get the basic "streamperf"
numbers. If the user has specified a verbosity of greater than 1,
we will display a veritable plethora of background information
from outside of this block as it it not cpu_measurement
specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
break;
case 1:
case 2:
if (print_headers) {
if ('x' == libfmt) {
fprintf(where,
cpu_title,
local_cpu_method,
remote_cpu_method);
}
else {
fprintf(where,
cpu_title_tput,
format_units(),
local_cpu_method,
remote_cpu_method);
}
}
fprintf(where,
cpu_fmt_1_line_1, /* the format string */
lss_size, /* local sendbuf size */
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* guess */
elapsed_time, /* how long was the test */
thruput,
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand, /* remote service demand */
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
fprintf(where,
cpu_fmt_1_line_2,
rss_size,
rsr_size);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
('x' == libfmt) ? tput_title : tput_title_band,
format_units());
}
fprintf(where,
tput_fmt_1_line_1, /* the format string */
lss_size,
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* how large were the responses */
elapsed_time, /* how long did it take */
/* are we trans or do we need to convert to bytes then
bits? at this point, thruput is in our "confident"
transactions per second. we can convert to a
bidirectional bitrate by multiplying that by the sum
of the req_size and rsp_size. we pass that to
calc_thruput_interval_omni with an elapsed time of
1.0 s to get it converted to [kmg]bits/s or
[KMG]Bytes/s */
thruput,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
fprintf(where,
tput_fmt_1_line_2,
rss_size, /* remote recvbuf size */
rsr_size);
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
/* how to handle the verbose information in the presence of */
/* confidence intervals is yet to be determined... raj 11/94 */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* TCP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
/* normally, you might think that if we were messing about with
the value of libfmt we would need to put it back again, but
since this is basically the last thing we are going to do with
it, it does not matter. so there :) raj 2007-06-08 */
/* if the user was asking for transactions, then we report
megabits per second for the unidirectional throughput,
otherwise we use the desired units. */
if ('x' == libfmt) {
libfmt = 'm';
}
fprintf(where,
ksink_fmt,
format_units(),
local_send_align,
remote_recv_offset,
local_send_offset,
remote_recv_offset,
/* if the user has enable burst mode, we have to remember
to account for that in the number of transactions
outstanding at any one time. otherwise we will
underreport the latency of individual
transactions. learned from saf by raj 2007-06-08 */
(((double)1.0/transaction_rate)*(double)1000000.0) *
(double) (1 + ((first_burst_size > 0) ? first_burst_size : 0)),
transaction_rate,
calc_thruput_interval_omni(transaction_rate * (double)req_size,
1.0),
calc_thruput_interval_omni(transaction_rate * (double)rsp_size,
1.0));
#ifdef WANT_HISTOGRAM
fprintf(where,"\nHistogram of request/response times\n");
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
fflush(where);
}
}
}
void
send_tcp_conn_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 = "\n\
Alignment Offset\n\
Local Remote Local Remote\n\
Send Recv Send Recv\n\
%5d %5d %5d %5d\n";
send_omni_inner(remote_host,
legacy,
"MIGRATED TCP Connect/Request/Response TEST");
/* We are now ready to print all the information. If the user */
/* has specified zero-level verbosity, we will just print the */
/* local service demand, or the remote service demand. If the */
/* user has requested verbosity level 1, he will get the basic */
/* "streamperf" numbers. If the user has specified a verbosity */
/* of greater than 1, we will display a veritable plethora of */
/* background information from outside of this block as it it */
/* not cpu_measurement specific... */
if (legacy) {
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1_line_1, /* the format string */
lss_size, /* local sendbuf size */
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* guess */
elapsed_time, /* how long was the test */
thruput,
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand); /* remote service demand */
fprintf(where,
cpu_fmt_1_line_2,
rss_size,
rsr_size);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
fprintf(where,
tput_fmt_1_line_1, /* the format string */
lss_size,
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* how large were the responses */
elapsed_time, /* how long did it take */
thruput);
fprintf(where,
tput_fmt_1_line_2,
rss_size, /* remote recvbuf size */
rsr_size);
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
/* how to handle the verbose information in the presence of */
/* confidence intervals is yet to be determined... raj 11/94 */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* TCP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
fprintf(where,
ksink_fmt,
local_send_align,
remote_recv_align,
local_send_offset,
remote_recv_offset);
#ifdef WANT_HISTOGRAM
fprintf(where,"\nHistogram of request/response times\n");
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
fflush(where);
}
}
}
void
send_udp_stream(char remote_host[])
{
/**********************************************************************/
/* */
/* UDP 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 = "\
%6d %6d %-7.2f %7"PRIu64" %6d %7.2f\n\
%6d %-7.2f %7"PRIu64" %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 %% %c%c us/KB\n\n";
char *cpu_fmt_0 =
"%6.2f %c\n";
char *cpu_fmt_1 = "\
%6d %6d %-7.2f %7"PRIu64" %6d %7.1f %-6.2f %-6.3f\n\
%6d %-7.2f %7"PRIu64" %7.1f %-6.2f %-6.3f\n\n";
send_omni_inner(remote_host, legacy, "MIGRATED UDP STREAM TEST");
if (legacy) {
/* We are now ready to print all the information. If the user has
specified zero-level verbosity, we will just print the local
service demand, or the remote service demand. If the user has
requested verbosity level 1, he will get the basic "streamperf"
numbers. If the user has specified a verbosity of greater than
1, we will display a veritable plethora of background
information from outside of this block as it it not
cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
local_cpu_method);
}
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
cpu_title,
format_units(),
local_cpu_method,
remote_cpu_method);
}
fprintf(where,
cpu_fmt_1, /* the format string */
lss_size, /* local sendbuf size */
send_size, /* how large were the sends */
elapsed_time, /* how long was the test */
local_send_calls,
failed_sends,
local_send_thruput, /* what was the xfer rate */
local_cpu_utilization, /* local cpu */
local_service_demand, /* local service demand */
rsr_size,
elapsed_time,
remote_receive_calls,
remote_recv_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_send_thruput);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,tput_title,format_units());
}
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 */
local_send_calls,
failed_sends,
local_send_thruput,
rsr_size, /* remote recvbuf size */
elapsed_time,
remote_receive_calls,
remote_recv_thruput);
break;
}
}
#ifdef WANT_HISTOGRAM
if (verbosity > 1) {
fprintf(where,"\nHistogram of time spent in send() call\n");
HIST_report(time_hist);
}
#endif /* WANT_HISTOGRAM */
fflush(where);
}
}
void
send_udp_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_title_band = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed \n\
Send Recv Size Size Time Throughput \n\
bytes Bytes bytes bytes secs. %s/sec \n\n";
char *tput_fmt_0 =
"%7.2f %s\n";
char *tput_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %7.2f %s\n";
char *tput_fmt_1_line_2 = "\
%-6d %-6d\n";
char *cpu_title = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Trans. CPU CPU S.dem S.dem\n\
Send Recv Size Size Time Rate local remote local remote\n\
bytes bytes bytes bytes secs. per sec %% %c %% %c us/Tr us/Tr\n\n";
char *cpu_title_tput = "\
Local /Remote\n\
Socket Size Request Resp. Elapsed Tput CPU CPU S.dem S.dem\n\
Send Recv Size Size Time %-8.8s local remote local remote\n\
bytes bytes bytes bytes secs. per sec %% %c %% %c us/KB us/KB\n\n";
char *cpu_fmt_0 =
"%6.3f %c %s\n";
char *cpu_fmt_1_line_1 = "\
%-6d %-6d %-6d %-6d %-6.2f %-6.2f %-6.2f %-6.2f %-6.3f %-6.3f %s\n";
char *cpu_fmt_1_line_2 = "\
%-6d %-6d\n";
send_omni_inner(remote_host, legacy, "MIGRATED UDP REQUEST/RESPONSE TEST");
if (legacy) {
/* We are now ready to print all the information. If the user has
specified zero-level verbosity, we will just print the local
service demand, or the remote service demand. If the user has
requested verbosity level 1, he will get the basic "streamperf"
numbers. If the user has specified a verbosity of greater than
1, we will display a veritable plethora of background
information from outside of this block as it it not
cpu_measurement specific... */
if (confidence < 0) {
/* we did not hit confidence, but were we asked to look for it? */
if (iteration_max > 1) {
display_confidence();
}
}
if (local_cpu_usage || remote_cpu_usage) {
switch (verbosity) {
case 0:
if (local_cpu_usage) {
fprintf(where,
cpu_fmt_0,
local_service_demand,
local_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
else {
fprintf(where,
cpu_fmt_0,
remote_service_demand,
remote_cpu_method,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
}
break;
case 1:
case 2:
if (print_headers) {
if ('x' == libfmt) {
fprintf(where,
cpu_title,
local_cpu_method,
remote_cpu_method);
}
else {
fprintf(where,
cpu_title_tput,
format_units(),
local_cpu_method,
remote_cpu_method);
}
}
fprintf(where,
cpu_fmt_1_line_1, /* the format string */
lss_size, /* local sendbuf size */
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* guess */
elapsed_time, /* how long was the test */
thruput,
local_cpu_utilization, /* local cpu */
remote_cpu_utilization, /* remote cpu */
local_service_demand, /* local service demand */
remote_service_demand, /* remote service demand */
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
fprintf(where,
cpu_fmt_1_line_2,
rss_size,
rsr_size);
break;
}
}
else {
/* The tester did not wish to measure service demand. */
switch (verbosity) {
case 0:
fprintf(where,
tput_fmt_0,
thruput,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
break;
case 1:
case 2:
if (print_headers) {
fprintf(where,
('x' == libfmt) ? tput_title : tput_title_band,
format_units());
}
fprintf(where,
tput_fmt_1_line_1, /* the format string */
lss_size,
lsr_size,
req_size, /* how large were the requests */
rsp_size, /* how large were the responses */
elapsed_time, /* how long did it take */
thruput,
((print_headers) ||
(result_brand == NULL)) ? "" : result_brand);
fprintf(where,
tput_fmt_1_line_2,
rss_size, /* remote recvbuf size */
rsr_size);
break;
}
}
/* it would be a good thing to include information about some of the */
/* other parameters that may have been set for this test, but at the */
/* moment, I do not wish to figure-out all the formatting, so I will */
/* just put this comment here to help remind me that it is something */
/* that should be done at a later time. */
/* how to handle the verbose information in the presence of */
/* confidence intervals is yet to be determined... raj 11/94 */
if (verbosity > 1) {
/* The user wanted to know it all, so we will give it to him. */
/* This information will include as much as we can find about */
/* UDP statistics, the alignments of the sends and receives */
/* and all that sort of rot... */
#ifdef WANT_HISTOGRAM
fprintf(where,"\nHistogram of request/reponse times.\n");
HIST_report(time_hist);
#endif /* WANT_HISTOGRAM */
}
fflush(where);
}
}
#endif /* WANT_MIGRATION */
/* using legacy test names will cause certain default settings to be
made before we scan the test-specific arguments. raj 2010-07-20 */
static void
set_omni_defaults_by_legacy_testname() {
/* the uber defaults are for a unidirectional test using TCP */
protocol = IPPROTO_TCP;
socket_type = SOCK_STREAM;
connection_test = 0;
req_size = rsp_size = -1;
was_legacy = 1;
legacy = 1;
implicit_direction = 0; /* do we allow certain options to
implicitly affect the test direction? */
if (strcasecmp(test_name,"TCP_STREAM") == 0) {
direction = NETPERF_XMIT;
}
else if (strcasecmp(test_name,"TCP_MAERTS") == 0) {
direction = NETPERF_RECV;
}
else if (strcasecmp(test_name,"TCP_RR") == 0) {
req_size = rsp_size = 1;
direction = 0;
direction |= NETPERF_XMIT;
direction |= NETPERF_RECV;
}
else if (strcasecmp(test_name,"UDP_STREAM") == 0) {
protocol = IPPROTO_UDP;
socket_type = SOCK_DGRAM;
}
else if (strcasecmp(test_name,"UDP_RR") == 0) {
protocol = IPPROTO_UDP;
socket_type = SOCK_DGRAM;
direction = 0;
direction |= NETPERF_XMIT;
direction |= NETPERF_RECV;
req_size = rsp_size = 1;
}
else if (strcasecmp(test_name,"TCP_CC") == 0) {
direction = 0;
connection_test = 1;
}
else if (strcasecmp(test_name,"TCP_CRR") == 0) {
direction = 0;
direction |= NETPERF_XMIT;
direction |= NETPERF_RECV;
req_size = rsp_size = 1;
connection_test = 1;
}
else if (strcasecmp(test_name,"omni") == 0) {
/* there is not much to do here but clear the legacy flag */
was_legacy = 0;
legacy = 0;
implicit_direction = 1;
}
socket_type_str = hst_to_str(socket_type);
}
char omni_usage[] = "\n\
Usage: netperf [global options] -- [test options] \n\
\n\
OMNI and Migrated BSD Sockets Test Options:\n\
-b number Send number requests at start of _RR tests\n\
-c Explicitly declare this a connection test such as\n\
TCP_CRR or TCP_CC\n\
-C Set TCP_CORK when available\n\
-d direction Explicitly set test direction based on bitwise OR\n\
of 0x2 for transmit and 0x4 for receive. Default:\n\
based on test type\n\
-D [L][,R] Set TCP_NODELAY locally and/or remotely (TCP_*)\n\
-h Display this text\n\
-H name[/mask],fam Use name (or IP) and family as target of data connection\n\
A mask value will cause randomization of the IP used\n\
-k [file] Generate keyval output optionally based on file\n\
Use filename of '?' to get the list of choices\n\
-K loc[,rem] Set the local and/or remote congestion control\n\
algorithm to use on those platforms where it can\n\
be set.\n\
-L name[/mask],fam Use name (or IP) and family as source of data connection\n\
A mask value will cause randomization of the IP used\n\
-m local,remote Set the send size for _STREAM/_MAERTS tests\n\
-M local,remote Set the recv size for _STREAM/_MAERTS tests\n\
-n Use the connected socket for UDP locally\n\
-N Use the connected socket for UDP remotely\n\
-o [file] Generate CSV output optionally based on file\n\
Use filename of '?' to get the list of choices\n\
-O [file] Generate classic-style output based on file\n\
Use filename of '?' to get the list of choices\n\
-p min[,max] Set the min/max port numbers for TCP_CRR, TCP_TRR\n\
-P local[,remote] Set the local/remote port for the data socket\n\
-r req,[rsp] Set request/response sizes (TCP_RR, UDP_RR)\n\
-R 0/1 Allow routing of traffic on data connection.\n\
Default: 0 (off) for UDP_STREAM, 1 (on) otherwise\n\
-s send[,recv] Set local socket send/recv buffer sizes\n\
-S send[,recv] Set remote socket send/recv buffer sizes\n\
-t type Explicitly set socket type. Default is implicit\n\
based on other settings\n\
-T protocol Explicitly set data connection protocol. Default is\n\
implicit based on other settings\n\
-u uuid Use the supplied string as the UUID for this test.\n\
-4 Use AF_INET (eg IPv4) on both ends of the data conn\n\
-6 Use AF_INET6 (eg IPv6) on both ends of the data conn\n\
\n\
For those options taking two parms, at least one must be specified;\n\
specifying one value without a comma will set both parms to that\n\
value, specifying a value with a leading comma will set just the second\n\
parm, a value with a trailing comma will set just the first. To set\n\
each parm to unique values, specify both and separate them with a\n\
comma.\n";
void
print_omni_usage()
{
fwrite(omni_usage, sizeof(char), strlen(omni_usage), stdout);
exit(1);
}
void
scan_omni_args(int argc, char *argv[])
{
#define OMNI_ARGS "aBb:cCd:De:FgG:hH:i:Ij:kK:l:L:m:M:nNoOp:P:r:R:s:S:t:T:u:UVw:W:46"
extern char *optarg; /* pointer to option string */
int c;
int have_uuid = 0;
int have_R_option = 0;
char
arg1[BUFSIZ], /* argument holders */
arg2[BUFSIZ],
arg3[BUFSIZ];
if (debug) {
int i;
printf("%s called with the following argument vector\n",
__FUNCTION__);
for (i = 0; i< argc; i++) {
printf("%s ",argv[i]);
}
printf("\n");
}
/* double-check struct sizes */
{
const union netperf_request_struct * u = (const union netperf_request_struct *)0;
if (debug) {
fprintf(where, "sizeof(omni_request_struct)=%d/%d\n",
(int)sizeof(struct omni_request_struct),
(int)sizeof(u->content.test_specific_data));
fprintf(where, "sizeof(omni_response_struct)=%d/%d\n",
(int)sizeof(struct omni_response_struct),
(int)sizeof(u->content.test_specific_data));
fprintf(where, "sizeof(omni_results_struct)=%d/%d\n",
(int)sizeof(struct omni_results_struct),
(int)sizeof(u->content.test_specific_data));
}
assert(sizeof(struct omni_request_struct)
<= sizeof(u->content.test_specific_data));
assert(sizeof(struct omni_response_struct)
<= sizeof(u->content.test_specific_data));
assert(sizeof(struct omni_results_struct)
<= sizeof(u->content.test_specific_data));
}
strncpy(local_data_port,"0",sizeof(local_data_port));
strncpy(remote_data_port,"0",sizeof(remote_data_port));
/* this will handle setting default settings based on test name */
set_omni_defaults_by_legacy_testname();
/* 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, OMNI_ARGS)) != EOF) {
switch (c) {
case '?':
case '4':
remote_data_family = AF_INET;
local_data_family = AF_INET;
break;
case '6':
#if defined(AF_INET6)
remote_data_family = AF_INET6;
local_data_family = AF_INET6;
#else
fprintf(stderr,
"This netperf was not compiled on an IPv6 capable host!\n");
fflush(stderr);
exit(-1);
#endif
break;
case 'h':
print_omni_usage();
exit(1);
case 'a':
want_defer_accept = 1;
break;
case 'B':
want_use_pktinfo = 1;
break;
case 'b':
#ifdef WANT_FIRST_BURST
first_burst_size = atoi(optarg);
#else /* WANT_FIRST_BURST */
printf("Initial request burst functionality not compiled-in!\n");
#endif /* WANT_FIRST_BURST */
break;
case 'c':
/* this is a connection test */
connection_test = 1;
break;
case 'C':
#ifdef TCP_CORK
/* set TCP_CORK */
loc_tcpcork = 1;
rem_tcpcork = 1; /* however, at first, we ony have cork affect loc */
#else
printf("WARNING: TCP_CORK not available on this platform!\n");
#endif /* TCP_CORK */
break;
case 'd':
/* arbitrarily set the direction variable, but only for an
actual omni test and then disable implicit setting of
direction */
if (!was_legacy) {
direction = parse_direction(optarg);
implicit_direction = 0;
}
break;
case 'D':
/* set the TCP nodelay flag */
loc_nodelay = 1;
rem_nodelay = 1;
break;
case 'F':
#if defined(MSG_FASTOPEN)
use_fastopen = 1;
#else
printf("WARNING: TCP FASTOPEN not available on this platform!\n");
#endif
break;
case 'e':
/* set the rEceive timeout */
receive_timeout = atoi(optarg);
break;
case 'g':
/* enable SO_DEBUG, or at least make the attempt, on the data socket */
socket_debug = 1;
break;
case 'G':
/* set the value for a tcp_maxseG call*/
transport_mss_req = atoi(optarg);
break;
case 'H':
break_args_explicit_sep(optarg,',',arg1,arg2);
if (arg1[0]) {
/* check to see if there was a width, which we would want to
be arg3. for simplicities sake, we will assume the width
must follow the address and not the address family - ie
1.2.3.4/24,inet. This means we can just pass optarg again
as the source rather than have to shuffle arg values. */
break_args_explicit_sep(optarg,'/',arg1,arg3);
if (arg1[0]) {
remote_data_address = malloc(strlen(arg1)+1);
strcpy(remote_data_address,arg1);
explicit_data_address = 1;
}
if (arg3[0]) {
remote_mask_len = convert(arg3);
}
}
if (arg2[0]) {
remote_data_family = parse_address_family(arg2);
}
break;
case 'i':
fprintf(stderr,"The support for check_interval has been removed because the contributing editor no longer knew what it was for\n");
fflush(stderr);
break;
case 'I':
use_write = 1;
break;
case 'j':
parallel_connections = atoi(optarg);
break;
case 'k':
netperf_output_mode = KEYVAL;
legacy = 0;
/* obliterate any previous file name */
if (output_selection_spec) {
free(output_selection_spec);
output_selection_spec = NULL;
}
if (argv[optind] && ((unsigned char)argv[optind][0] != '-')) {
/* we assume that what follows is the name of a file with the
list of desired output values. */
output_selection_spec = strdup(argv[optind]);
optind++;
/* special case - if the file name is "?" then we will emit a
list of the available outputs */
if (strcmp(output_selection_spec,"?") == 0) {
dump_netperf_output_choices(stdout,1);
exit(1);
}
}
break;
case 'K':
/* "Kongestion Kontrol */
break_args(optarg,arg1,arg2);
if (arg1[0])
strncpy(local_cong_control_req,arg1,sizeof(local_cong_control_req));
if (arg2[2])
strncpy(remote_cong_control_req,arg2,sizeof(remote_cong_control_req));
break;
case 'l':
multicast_ttl = atoi(optarg);
break;
case 'L':
break_args_explicit_sep(optarg,',',arg1,arg2);
if (arg1[0]) {
/* check to see if there was a width, which we would want to
be arg3. for simplicities sake, we will assume the width
must follow the address and not the address family - ie
1.2.3.4/24,inet. This means we can just pass optarg again
as the source rather than have to shuffle arg values. */
break_args_explicit_sep(optarg,'/',arg1,arg3);
if (arg1[0]) {
local_data_address = malloc(strlen(arg1)+1);
strcpy(local_data_address,arg1);
}
if (arg3[0]) {
local_mask_len = convert(arg3);
}
}
if (arg2[0]) {
local_data_family = parse_address_family(arg2);
}
break;
case 'm':
/* set the send size. if we set the local send size it will add
XMIT to direction. if we set the remote send size it will
add RECV to the direction. likely as not this will need some
additional throught */
break_args_explicit(optarg,arg1,arg2);
if (arg1[0]) {
send_size = convert(arg1);
if (implicit_direction)
direction |= NETPERF_XMIT;
}
if (arg2[0]) {
remote_send_size_req = convert(arg2);
if (implicit_direction)
direction |= NETPERF_RECV;
}
break;
case 'M':
/* set the recv sizes. if we set the local recv size it will
add RECV to direction. if we set the remote recv size it
will add XMIT to direction */
break_args_explicit(optarg,arg1,arg2);
if (arg1[0]) {
remote_recv_size_req = convert(arg1);
if (implicit_direction)
direction |= NETPERF_XMIT;
}
if (arg2[0]) {
recv_size = convert(arg2);
if (implicit_direction)
direction |= NETPERF_RECV;
}
break;
case 'n':
/* set the local socket type */
local_connected = 1;
break;
case 'N':
/* set the remote socket type */
remote_connected = 1;
break;
case 'o':
netperf_output_mode = CSV;
legacy = 0;
/* obliterate any previous file name */
if (output_selection_spec) {
free(output_selection_spec);
output_selection_spec = NULL;
}
if (output_selection_spec) {
free(output_selection_spec);
output_selection_spec = NULL;
}
if (argv[optind] && ((unsigned char)argv[optind][0] != '-')) {
/* we assume that what follows is the name of a file with the
list of desired output values. */
output_selection_spec = strdup(argv[optind]);
optind++;
/* special case - if the file name is "?" then we will emit a
list of the available outputs */
if (strcmp(output_selection_spec,"?") == 0) {
dump_netperf_output_choices(stdout,1);
exit(1);
}
}
break;
case 'O':
netperf_output_mode = HUMAN;
legacy = 0;
/* obliterate any previous file name */
if (output_selection_spec) {
free(output_selection_spec);
output_selection_spec = NULL;
}
if (argv[optind] && ((unsigned char)argv[optind][0] != '-')) {
/* we assume that what follows is the name of a file with the
list of desired output values */
output_selection_spec = strdup(argv[optind]);
optind++;
if (strcmp(output_selection_spec,"?") == 0) {
dump_netperf_output_choices(stdout,0);
exit(1);
}
}
break;
case 'p':
/* set the min and max port numbers for the TCP_CRR and TCP_TRR */
/* tests. */
break_args(optarg,arg1,arg2);
if (arg1[0])
client_port_min = atoi(arg1);
if (arg2[0])
client_port_max = atoi(arg2);
break;
case 'P':
/* set the local and remote data port numbers for the tests to
allow them to run through those blankety blank end-to-end
breaking firewalls. raj 2004-06-15 */
break_args(optarg,arg1,arg2);
if (arg1[0])
strncpy(local_data_port,arg1,sizeof(local_data_port));
if (arg2[0])
strncpy(remote_data_port,arg2,sizeof(remote_data_port));
break;
case 'r':
/* set the request/response sizes. setting request/response
sizes implicitly sets direction to XMIT and RECV */
if (implicit_direction) {
direction |= NETPERF_XMIT;
direction |= NETPERF_RECV;
}
break_args(optarg,arg1,arg2);
if (arg1[0])
req_size = convert(arg1);
if (arg2[0])
rsp_size = convert(arg2);
break;
case 'R':
routing_allowed = atoi(optarg);
have_R_option = 1;
break;
case 's':
/* set local socket sizes */
break_args(optarg,arg1,arg2);
if (arg1[0])
lss_size_req = convert(arg1);
if (arg2[0])
lsr_size_req = convert(arg2);
break;
case 'S':
/* set remote socket sizes */
break_args(optarg,arg1,arg2);
if (arg1[0])
rss_size_req = convert(arg1);
if (arg2[0])
rsr_size_req = convert(arg2);
break;
case 't':
/* set the socket type */
socket_type = parse_socket_type(optarg);
break;
case 'T':
/* set the protocol - aka "Transport" */
protocol = parse_protocol(optarg);
break;
case 'u':
/* use the supplied string as the UUID for this test. at some
point we may want to sanity check the string we are given but
for now we won't worry about it */
strncpy(test_uuid,optarg,sizeof(test_uuid));
/* strncpy may leave us with a string without a null at the end */
test_uuid[sizeof(test_uuid) - 1] = 0;
have_uuid = 1;
break;
case 'U':
/* we don't want to give-up on the failure of a connect() call */
dont_give_up = 1;
break;
case 'W':
/* set the "width" of the user space data */
/* buffer. This will be the number of */
/* send_size buffers malloc'd in the */
/* *_STREAM test. It may be enhanced to set */
/* both send and receive "widths" but for now */
/* it is just the sending *_STREAM. */
send_width = convert(optarg);
break;
case 'V' :
/* we want to do copy avoidance and will set */
/* it for everything, everywhere, if we really */
/* can. of course, we don't know anything */
/* about the remote... */
loc_sndavoid = 1;
loc_rcvavoid = 1;
rem_sndavoid = 1;
rem_rcvavoid = 1;
break;
};
}
/* generate the UUID for this test if the user has not supplied it */
if (!have_uuid)
get_uuid_string(test_uuid,sizeof(test_uuid));
protocol_str = protocol_to_str(protocol);
/* ok, if we have gone through all that, and direction is still
zero, let us see if it needs to be set to something else. */
if ((0 == direction) && (!connection_test)) direction = NETPERF_XMIT;
direction_str = direction_to_str(direction);
/* to cover the backside of blithering idiots who run unidirectional
UDP tests on test setups where they might trash their corporate
WAN, we grudgingly provide a safety latch. unless explicitly
enabled, UDP_STREAM/UDP_MAERTS sockets will not allow themselves
to be routed via a gateway. raj 20091026 */
if ((!have_R_option) &&
(protocol == IPPROTO_UDP) &&
(!NETPERF_IS_RR(direction))) {
routing_allowed = 0;
}
/* some other sanity checks we need to make would include stuff when
the user has set -m and -M such that both XMIT and RECV are set
and has not set -r. initially we will not allow that. at some
point we might allow that if the user has also set -r, but until
then the code will simply ignore the values from -m and -M when
-r is set. */
#if defined(WANT_HISTOGRAM)
if (verbosity > 1) keep_histogram = 1;
#endif
/* did the user use -d 6 but not set -r? */
if (NETPERF_IS_RR(direction) && !NETPERF_CC(direction)) {
if (req_size == -1)
req_size = 1;
if (rsp_size == -1)
rsp_size = 1;
}
/* ok, time to sanity check the output units */
if ('?' == libfmt) {
/* if this is a RR test then set it to 'x' for transactions */
if (NETPERF_IS_RR(direction)) {
libfmt = 'x';
}
else {
libfmt = 'm';
}
}
else if ('x' == libfmt) {
/* now, a format of 'x' makes no sense for anything other than
an RR test. if someone has been silly enough to try to set
that, we will reset it silently to default - namely 'm' */
if (!NETPERF_IS_RR(direction)) {
libfmt = 'm';
}
}
/* this needs to be strdup :) */
thruput_format_str = strdup(format_units());
/* so, if there is to be no control connection, we want to have some
different settings for a few things */
if (no_control) {
if (strcmp(remote_data_port,"0") == 0) {
/* we need to select either the discard port, echo port or
chargen port dedepending on the test direction. raj
20101220 */
if (NETPERF_XMIT_ONLY(direction)) {
strncpy(remote_data_port,"discard",sizeof(remote_data_port));
recv_size = -1;
}
else if (NETPERF_RECV_ONLY(direction)) {
strncpy(remote_data_port,"chargen",sizeof(remote_data_port));
send_size = -1;
}
else if (NETPERF_IS_RR(direction) || NETPERF_CC(direction)) {
strncpy(remote_data_port,"echo",sizeof(remote_data_port));
rsp_size = req_size;
}
else {
printf("No default port known for the %s test, please set one yourself\n",test_name);
exit(-1);
}
}
remote_data_port[sizeof(remote_data_port) - 1] = '\0';
/* I go back and forth on whether these should become -1 or if
they should become 0 for a no_control test. what do you think?
raj 2006-02-08 */
rem_rcvavoid = -1;
rem_sndavoid = -1;
rss_size_req = -1;
rsr_size_req = -1;
rem_nodelay = -1;
}
/* so, did the user request a few things implicitly via output selection? */
if (!legacy)
print_omni_init();
if (desired_output_groups & OMNI_WANT_STATS) {
keep_statistics = 1;
keep_histogram = 1;
}
}
#endif /* WANT_OMNI */