| #ifdef HAVE_CONFIG_H |
| #include <config.h> |
| #endif |
| |
| #ifdef WANT_OMNI |
| char nettest_omni_id[]="\ |
| @(#)nettest_omni.c (c) Copyright 2008 Hewlett-Packard Co. Version 2.5.0pre"; |
| |
| #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 |
| |
| #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 */ |
| |
| #ifdef WANT_SCTP |
| #include <netinet/sctp.h> |
| #endif |
| |
| #ifndef WIN32 |
| #if !defined(__VMS) |
| #include <sys/ipc.h> |
| #endif /* !defined(__VMS) */ |
| #include <sys/socket.h> |
| #include <netinet/in.h> |
| #include <netinet/tcp.h> |
| #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) |
| |
| #define __func__ __FUNCTION__ |
| #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" |
| |
| #if defined(WANT_HISTOGRAM) || defined(WANT_DEMO) |
| #include "hist.h" |
| #endif /* WANT_HISTOGRAM */ |
| |
| #ifdef WANT_HISTOGRAM |
| #ifdef HAVE_GETHRTIME |
| static hrtime_t time_one; |
| static hrtime_t time_two; |
| #elif HAVE_GET_HRT |
| #include "hrt.h" |
| static hrt_t time_one; |
| static hrt_t time_two; |
| #elif defined(WIN32) |
| static LARGE_INTEGER time_one; |
| static LARGE_INTEGER time_two; |
| #else |
| static struct timeval time_one; |
| static struct timeval time_two; |
| #endif /* HAVE_GETHRTIME */ |
| static HIST time_hist; |
| #endif /* WANT_HISTOGRAM */ |
| |
| #ifdef WANT_DEMO |
| #ifdef HAVE_GETHRTIME |
| static hrtime_t demo_one; |
| static hrtime_t demo_two; |
| static hrtime_t *demo_one_ptr = &demo_one; |
| static hrtime_t *demo_two_ptr = &demo_two; |
| static hrtime_t *temp_demo_ptr = &demo_one; |
| #elif defined(WIN32) |
| static LARGE_INTEGER demo_one; |
| static LARGE_INTEGER demo_two; |
| static LARGE_INTEGER *demo_one_ptr = &demo_one; |
| static LARGE_INTEGER *demo_two_ptr = &demo_two; |
| static LARGE_INTEGER *temp_demo_ptr = &demo_one; |
| #else |
| static struct timeval demo_one; |
| static struct timeval demo_two; |
| static struct timeval *demo_one_ptr = &demo_one; |
| static struct timeval *demo_two_ptr = &demo_two; |
| static struct timeval *temp_demo_ptr = &demo_one; |
| #endif |
| |
| /* for a _STREAM test, "a" should be lss_size and "b" should be |
| rsr_size. for a _MAERTS test, "a" should be lsr_size and "b" should |
| be rss_size. raj 2005-04-06 */ |
| #define DEMO_STREAM_SETUP(a,b) \ |
| if ((demo_mode) && (demo_units == 0)) { \ |
| /* take our default value of demo_units to be the larger of \ |
| twice the remote's SO_RCVBUF or twice our SO_SNDBUF */ \ |
| if (a > b) { \ |
| demo_units = 2*a; \ |
| } \ |
| else { \ |
| demo_units = 2*b; \ |
| } \ |
| } |
| |
| #define DEMO_INTERVAL(units) \ |
| if (demo_mode) { \ |
| double actual_interval; \ |
| units_this_tick += units; \ |
| if (units_this_tick >= demo_units) { \ |
| /* time to possibly update demo_units and maybe output an \ |
| interim result */ \ |
| HIST_timestamp(demo_two_ptr); \ |
| actual_interval = delta_micro(demo_one_ptr,demo_two_ptr); \ |
| /* we always want to fine-tune demo_units here whether we \ |
| emit an interim result or not. if we are short, this \ |
| will lengthen demo_units. if we are long, this will \ |
| shorten it */ \ |
| demo_units = demo_units * (demo_interval / actual_interval); \ |
| if (actual_interval >= demo_interval) { \ |
| /* time to emit an interim result */ \ |
| fprintf(where, \ |
| "Interim result: %7.2f %s/s over %.2f seconds\n", \ |
| calc_thruput_interval(units_this_tick, \ |
| actual_interval/1000000.0), \ |
| format_units(), \ |
| actual_interval/1000000.0); \ |
| units_this_tick = 0.0; \ |
| /* now get a new starting timestamp. we could be clever \ |
| and swap pointers - the math we do probably does not \ |
| take all that long, but for now this will suffice */ \ |
| temp_demo_ptr = demo_one_ptr; \ |
| demo_one_ptr = demo_two_ptr; \ |
| demo_two_ptr = temp_demo_ptr; \ |
| } \ |
| } \ |
| } |
| |
| #define DEMO_STREAM_INTERVAL(units) DEMO_INTERVAL(units) |
| |
| #define DEMO_RR_SETUP(a) \ |
| if ((demo_mode) && (demo_units == 0)) { \ |
| /* take whatever we are given */ \ |
| demo_units = a; \ |
| } |
| |
| #define DEMO_RR_INTERVAL(units) DEMO_INTERVAL(units) |
| |
| #endif |
| |
| #ifdef WANT_INTERVALS |
| int interval_count; |
| #ifndef WANT_SPIN |
| 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; \ |
| /* 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", \ |
| __func__, \ |
| errno); \ |
| fflush(where); \ |
| exit(1); \ |
| } |
| |
| #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); \ |
| } \ |
| if (sigsuspend(&signal_set) == EFAULT) { \ |
| fprintf(where, \ |
| "%s: fault with sigsuspend.\n", \ |
| __func__); \ |
| fflush(where); \ |
| exit(1); \ |
| } \ |
| interval_count = interval_burst; \ |
| } |
| #else |
| /* first out timestamp */ |
| #ifdef HAVE_GETHRTIME |
| static hrtime_t intvl_one; |
| static hrtime_t intvl_two; |
| 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_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_one_ptr = &intvl_one; |
| static struct timeval *intvl_two_ptr = &intvl_two; |
| static struct timeval *temp_intvl_ptr = &intvl_one; |
| #endif |
| |
| #define INTERVALS_INIT() \ |
| if (interval_burst) { \ |
| HIST_timestamp(intvl_one_ptr); \ |
| } \ |
| 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)) { \ |
| /* call sigsuspend 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_two_ptr); \ |
| while(delta_micro(intvl_one_ptr,intvl_two_ptr) < interval_usecs) { \ |
| HIST_timestamp(intvl_two_ptr); \ |
| } \ |
| 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 |
| #define NETPERF_XMIT 0x2 |
| #define NETPERF_RECV 0x4 |
| |
| #define NETPERF_IS_RR(x) (((x & NETPERF_XMIT) && (x & NETPERF_RECV)) || \ |
| (!((x & NETPERF_XMIT) || (x & NETPERF_RECV)))) |
| |
| #define NETPERF_RECV_ONLY(x) ((x & NETPERF_RECV) && !(x & NETPERF_XMIT)) |
| |
| #define NETPERF_XMIT_ONLY(x) ((x & NETPERF_XMIT) && !(x & NETPERF_RECV)) |
| |
| #define NETPERF_CC(x) (!(x & NETPERF_XMIT) && !(x & NETPERF_RECV)) |
| |
| extern void get_uuid_string(char *string, size_t size); |
| |
| /* a boatload of globals while I settle things out */ |
| char *csv_selection_file = NULL; |
| char *human_selection_file = NULL; |
| char *keyword_selection_file = 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; |
| #if 0 |
| int remote_send_dirty_count; |
| int remote_recv_dirty_count; |
| int remote_recv_clean_count; |
| #endif |
| 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 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 csv = 0; |
| int keyword = 0; |
| uint64_t trans_completed = 0; |
| uint64_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_cpu_utilization_double; |
| double local_service_demand_double; |
| double remote_cpu_utilization_double; |
| double remote_service_demand_double; |
| double transaction_rate = 1.0; |
| double rtt_latency = -1.0; |
| int32_t transport_mss = -2; |
| char *local_interface_name=NULL; |
| char *remote_interface_name=NULL; |
| char local_driver_name[32]=""; |
| char local_driver_version[32]=""; |
| char local_driver_firmware[32]=""; |
| char local_driver_bus[32]=""; |
| char remote_driver_name[32]=""; |
| char remote_driver_version[32]=""; |
| char remote_driver_firmware[32]=""; |
| char remote_driver_bus[32]=""; |
| char *local_interface_slot=NULL; |
| char *remote_interface_slot=NULL; |
| int remote_interface_vendor; |
| int remote_interface_device; |
| int remote_interface_subvendor; |
| int remote_interface_subdevice; |
| int local_interface_vendor; |
| int local_interface_device; |
| int local_interface_subvendor; |
| int local_interface_subdevice; |
| char *local_system_model; |
| char *local_cpu_model; |
| int local_cpu_frequency; |
| char *remote_system_model; |
| char *remote_cpu_model; |
| int remote_cpu_frequency; |
| |
| int local_security_type_id; |
| int local_security_enabled_num; |
| char *local_security_type; |
| char *local_security_enabled; |
| char *local_security_specific; |
| int remote_security_type_id; |
| int remote_security_enabled_num; |
| char *remote_security_enabled; |
| char *remote_security_type; |
| char *remote_security_specific; |
| |
| 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; |
| |
| #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; |
| |
| /* you should add to this in the order in which they should appear in |
| the default csv (everything) output */ |
| |
| enum netperf_output_name { |
| 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_METHOD, |
| LOCAL_SD, |
| REMOTE_CPU_UTIL, |
| 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, |
| 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, |
| COMMAND_LINE, |
| OUTPUT_END, |
| NETPERF_OUTPUT_MAX |
| }; |
| |
| 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 *brief; /* the brief name of the value */ |
| char *format; /* format to apply to value */ |
| void *display_value; /* where to find the value */ |
| } netperf_output_elt_t; |
| |
| netperf_output_elt_t netperf_output_source[NETPERF_OUTPUT_MAX]; |
| |
| /* the list of things we will emit for CSV output. I suppose we could |
| at some point try to make this a special case of output_human_list, |
| or at least use some of that space... but for now we won't worry |
| about it. that can come after things are actually working :) raj |
| 2008-01-23 */ |
| enum netperf_output_name output_csv_list[NETPERF_OUTPUT_MAX]; |
| |
| /* the list of things we will emit for "human" output. up to |
| NETPERF_MAX_BLOCKS of output (groups of lines) each out to |
| NETPERF_OUTPUT_MAX entries. that should more than cover it */ |
| |
| #define NETPERF_MAX_BLOCKS 4 |
| enum netperf_output_name output_human_list[NETPERF_MAX_BLOCKS][NETPERF_OUTPUT_MAX]; |
| |
| 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 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); |
| } |
| } |
| |
| 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 = 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 = client_port_min; |
| } |
| |
| /* set up the data socket */ |
| set_port_number(local_res, (unsigned short)myport); |
| } |
| |
| 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 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_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_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 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 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", |
| netperf_output_enum_to_str(netperf_output_source[i].output_name)); |
| fprintf(where, |
| "\tmax_line_len %d tot_line_len %d display_value %p\n", |
| netperf_output_source[i].max_line_len, |
| netperf_output_source[i].tot_line_len, |
| netperf_output_source[i].display_value); |
| fprintf(where, |
| "\tline[0]: |%s|\n", |
| (netperf_output_source[i].line[0] == NULL) ? "" : |
| netperf_output_source[i].line[0]); |
| fprintf(where, |
| "\tline[1]: |%s|\n", |
| (netperf_output_source[i].line[1] == NULL) ? "" : |
| netperf_output_source[i].line[1]); |
| fprintf(where, |
| "\tline[2]: |%s|\n", |
| (netperf_output_source[i].line[2] == NULL) ? "" : |
| netperf_output_source[i].line[2]); |
| fprintf(where, |
| "\tline[3]: |%s|\n", |
| (netperf_output_source[i].line[3] == NULL) ? "" : |
| netperf_output_source[i].line[3]); |
| fprintf(where, |
| "\tbrief: |%s|\n", |
| (netperf_output_source[i].brief == NULL) ? "" : |
| netperf_output_source[i].brief); |
| fprintf(where, |
| "\tformat: |%s|\n", |
| (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(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 |
| parse_output_csv_selection_file(char *selection_file) { |
| FILE *selections; |
| char name[81]; /* best be more than enough */ |
| int namepos; |
| int c; |
| int j; |
| enum netperf_output_name match; |
| int line,column; |
| |
| selections = fopen(selection_file,"r"); |
| if (!selections) { |
| perror("Could Not Open output selection file"); |
| exit(-1); |
| } |
| |
| /* should this really be necessary? */ |
| rewind(selections); |
| |
| line = 0; |
| column = 1; |
| namepos = 0; |
| name[0] = 0; |
| name[80] = 0; |
| j = 0; |
| /* let's allow the csv to turn the four lines of a human readable |
| output file to be used to create a single line csv output file by |
| not worrying about the line count. raj 2008--02-04 */ |
| while ((c = fgetc(selections)) != EOF) { |
| 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_csv_list[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_csv_list[j++] = match_string_to_output(name); |
| line++; |
| namepos = 0; |
| } |
| else if (isprint(c)) { |
| name[namepos++] = 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_csv_list[j] = match_string_to_output(name); |
| } |
| } |
| void |
| parse_output_human_selection_file(char *selection_file) { |
| FILE *selections; |
| char name[81]; /* best be more than enough */ |
| int namepos; |
| char c; |
| int j; |
| enum netperf_output_name match; |
| int line,column; |
| |
| selections = fopen(selection_file,"r"); |
| if (!selections) { |
| perror("Could Not Open output selection file"); |
| 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_human_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_human_list[line++][j++] = match_string_to_output(name); |
| namepos = 0; |
| j = 0; |
| } |
| else if (isprint(c)) { |
| name[namepos++] = 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_human_list[line][j] = match_string_to_output(name); |
| } |
| |
| } |
| |
| void |
| set_output_csv_list_default() { |
| |
| int i = 0; |
| enum netperf_output_name j; |
| |
| /* this should cause us to catch everything unless someone botches |
| adding an output name to the enum. raj 2008-02-22 */ |
| for (j = SOCKET_TYPE; j < OUTPUT_END; j++) { |
| output_csv_list[i++] = j; |
| } |
| |
| } |
| |
| void |
| set_output_human_list_default() { |
| |
| 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_human_list[i][j++] = k; |
| |
| /* Line Two LOCAL_CPU_UTIL to TRANSPORT_MSS */ |
| i = 1; |
| j = 0; |
| for (k = LOCAL_CPU_UTIL; k <= TRANSPORT_MSS; k++) |
| output_human_list[i][j++] = k; |
| |
| /* Line Three LOCAL_SEND_THROUGHPUT throught REMOTE_CORK */ |
| i = 2; |
| j = 0; |
| for (k = LOCAL_SEND_THROUGHPUT; k <= REMOTE_CORK; k++) |
| output_human_list[i][j++] = k; |
| |
| /* Line Four LOCAL_SYSNAME through COMMAND_LINE */ |
| i = 3; |
| j = 0; |
| for (k = LOCAL_SYSNAME; k <= COMMAND_LINE; k++) |
| output_human_list[i][j++] = k; |
| |
| } |
| |
| void |
| print_omni_init_list() { |
| |
| int i; |
| |
| /* belts and suspenders everyone... */ |
| for (i = OUTPUT_NONE; 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].brief = ""; |
| netperf_output_source[i].format = ""; |
| netperf_output_source[i].display_value = NULL; |
| } |
| |
| netperf_output_source[OUTPUT_NONE].output_name = OUTPUT_NONE; |
| netperf_output_source[OUTPUT_NONE].line[0] = " "; |
| netperf_output_source[OUTPUT_NONE].format = "%s"; |
| netperf_output_source[OUTPUT_NONE].display_value = &" "; |
| netperf_output_source[OUTPUT_NONE].max_line_len = |
| NETPERF_LINE_MAX(OUTPUT_NONE); |
| netperf_output_source[OUTPUT_NONE].tot_line_len = |
| NETPERF_LINE_TOT(OUTPUT_NONE); |
| |
| netperf_output_source[COMMAND_LINE].output_name = COMMAND_LINE; |
| netperf_output_source[COMMAND_LINE].line[0] = "Command"; |
| netperf_output_source[COMMAND_LINE].line[1] = "Line"; |
| netperf_output_source[COMMAND_LINE].format = "\"%s\""; |
| netperf_output_source[COMMAND_LINE].display_value = command_line; |
| netperf_output_source[COMMAND_LINE].max_line_len = |
| NETPERF_LINE_MAX(COMMAND_LINE); |
| netperf_output_source[COMMAND_LINE].tot_line_len = |
| NETPERF_LINE_TOT(COMMAND_LINE); |
| |
| netperf_output_source[UUID].output_name = UUID; |
| netperf_output_source[UUID].line[0] = "Test"; |
| netperf_output_source[UUID].line[1] = "UUID"; |
| netperf_output_source[UUID].format = "%s"; |
| netperf_output_source[UUID].display_value = test_uuid; |
| netperf_output_source[UUID].max_line_len = |
| NETPERF_LINE_MAX(UUID); |
| netperf_output_source[UUID].tot_line_len = |
| NETPERF_LINE_TOT(UUID); |
| |
| netperf_output_source[RESULT_BRAND].output_name = RESULT_BRAND; |
| netperf_output_source[RESULT_BRAND].line[0] = "Result"; |
| netperf_output_source[RESULT_BRAND].line[1] = "Tag"; |
| netperf_output_source[RESULT_BRAND].format = "\"%s\""; |
| netperf_output_source[RESULT_BRAND].display_value = result_brand; |
| netperf_output_source[RESULT_BRAND].max_line_len = |
| NETPERF_LINE_MAX(RESULT_BRAND); |
| netperf_output_source[RESULT_BRAND].tot_line_len = |
| NETPERF_LINE_TOT(RESULT_BRAND); |
| |
| netperf_output_source[SOCKET_TYPE].output_name = SOCKET_TYPE; |
| netperf_output_source[SOCKET_TYPE].line[0] = "Socket"; |
| netperf_output_source[SOCKET_TYPE].line[1] = "Type"; |
| netperf_output_source[SOCKET_TYPE].format = "%s"; |
| netperf_output_source[SOCKET_TYPE].display_value = socket_type_str; |
| netperf_output_source[SOCKET_TYPE].max_line_len = |
| NETPERF_LINE_MAX(SOCKET_TYPE); |
| netperf_output_source[SOCKET_TYPE].tot_line_len = |
| NETPERF_LINE_TOT(SOCKET_TYPE); |
| |
| netperf_output_source[DIRECTION].output_name = DIRECTION; |
| netperf_output_source[DIRECTION].line[0] = "Direction"; |
| netperf_output_source[DIRECTION].line[1] = ""; |
| netperf_output_source[DIRECTION].format = "%s"; |
| netperf_output_source[DIRECTION].display_value = direction_str; |
| netperf_output_source[DIRECTION].max_line_len = |
| NETPERF_LINE_MAX(DIRECTION); |
| netperf_output_source[DIRECTION].tot_line_len = |
| NETPERF_LINE_TOT(DIRECTION); |
| |
| netperf_output_source[PROTOCOL].output_name = PROTOCOL; |
| netperf_output_source[PROTOCOL].line[0] = "Protocol"; |
| netperf_output_source[PROTOCOL].format = "%s"; |
| netperf_output_source[PROTOCOL].display_value = protocol_str; |
| netperf_output_source[PROTOCOL].max_line_len = |
| NETPERF_LINE_MAX(PROTOCOL); |
| netperf_output_source[PROTOCOL].tot_line_len = |
| NETPERF_LINE_TOT(PROTOCOL); |
| |
| netperf_output_source[ELAPSED_TIME].output_name = ELAPSED_TIME; |
| netperf_output_source[ELAPSED_TIME].line[0] = "Elapsed"; |
| netperf_output_source[ELAPSED_TIME].line[1] = "Time"; |
| netperf_output_source[ELAPSED_TIME].line[2] = "(sec)"; |
| netperf_output_source[ELAPSED_TIME].format = "%.2f"; |
| netperf_output_source[ELAPSED_TIME].display_value = &elapsed_time_double; |
| netperf_output_source[ELAPSED_TIME].max_line_len = |
| NETPERF_LINE_MAX(ELAPSED_TIME); |
| netperf_output_source[ELAPSED_TIME].tot_line_len = |
| NETPERF_LINE_TOT(ELAPSED_TIME); |
| |
| netperf_output_source[SOURCE_PORT].output_name = SOURCE_PORT; |
| netperf_output_source[SOURCE_PORT].line[0] = "Source"; |
| netperf_output_source[SOURCE_PORT].line[1] = "Port"; |
| netperf_output_source[SOURCE_PORT].format = "%s"; |
| netperf_output_source[SOURCE_PORT].display_value = local_data_port; |
| netperf_output_source[SOURCE_PORT].max_line_len = |
| NETPERF_LINE_MAX(SOURCE_PORT); |
| netperf_output_source[SOURCE_PORT].tot_line_len = |
| NETPERF_LINE_TOT(SOURCE_PORT); |
| |
| netperf_output_source[SOURCE_ADDR].output_name = SOURCE_ADDR; |
| netperf_output_source[SOURCE_ADDR].line[0] = "Source"; |
| netperf_output_source[SOURCE_ADDR].line[1] = "Address"; |
| netperf_output_source[SOURCE_ADDR].format = "%s"; |
| netperf_output_source[SOURCE_ADDR].display_value = local_data_address; |
| netperf_output_source[SOURCE_ADDR].max_line_len = |
| NETPERF_LINE_MAX(SOURCE_ADDR); |
| netperf_output_source[SOURCE_ADDR].tot_line_len = |
| NETPERF_LINE_TOT(SOURCE_ADDR); |
| |
| netperf_output_source[SOURCE_FAMILY].output_name = SOURCE_FAMILY; |
| netperf_output_source[SOURCE_FAMILY].line[0] = "Source"; |
| netperf_output_source[SOURCE_FAMILY].line[1] = "Family"; |
| netperf_output_source[SOURCE_FAMILY].format = "%d"; |
| netperf_output_source[SOURCE_FAMILY].display_value = &local_data_family; |
| netperf_output_source[SOURCE_FAMILY].max_line_len = |
| NETPERF_LINE_MAX(SOURCE_FAMILY); |
| netperf_output_source[SOURCE_FAMILY].tot_line_len = |
| NETPERF_LINE_TOT(SOURCE_FAMILY); |
| |
| netperf_output_source[DEST_PORT].output_name = DEST_PORT; |
| netperf_output_source[DEST_PORT].line[0] = "Destination"; |
| netperf_output_source[DEST_PORT].line[1] = "Port"; |
| netperf_output_source[DEST_PORT].format = "%s"; |
| netperf_output_source[DEST_PORT].display_value = remote_data_port; |
| netperf_output_source[DEST_PORT].max_line_len = |
| NETPERF_LINE_MAX(DEST_PORT); |
| netperf_output_source[DEST_PORT].tot_line_len = |
| NETPERF_LINE_TOT(DEST_PORT); |
| |
| netperf_output_source[DEST_ADDR].output_name = DEST_ADDR; |
| netperf_output_source[DEST_ADDR].line[0] = "Destination"; |
| netperf_output_source[DEST_ADDR].line[1] = "Address"; |
| netperf_output_source[DEST_ADDR].format = "%s"; |
| netperf_output_source[DEST_ADDR].display_value = remote_data_address; |
| netperf_output_source[DEST_ADDR].max_line_len = |
| NETPERF_LINE_MAX(DEST_ADDR); |
| netperf_output_source[DEST_ADDR].tot_line_len = |
| NETPERF_LINE_TOT(DEST_ADDR); |
| |
| netperf_output_source[DEST_FAMILY].output_name = DEST_FAMILY; |
| netperf_output_source[DEST_FAMILY].line[0] = "Destination"; |
| netperf_output_source[DEST_FAMILY].line[1] = "Family"; |
| netperf_output_source[DEST_FAMILY].format = "%d"; |
| netperf_output_source[DEST_FAMILY].display_value = &remote_data_family; |
| netperf_output_source[DEST_FAMILY].max_line_len = |
| NETPERF_LINE_MAX(DEST_FAMILY); |
| netperf_output_source[DEST_FAMILY].tot_line_len = |
| NETPERF_LINE_TOT(DEST_FAMILY); |
| |
| netperf_output_source[THROUGHPUT].output_name = THROUGHPUT; |
| netperf_output_source[THROUGHPUT].line[0] = "Throughput"; |
| netperf_output_source[THROUGHPUT].line[1] = ""; |
| netperf_output_source[THROUGHPUT].format = "%.2f"; |
| netperf_output_source[THROUGHPUT].display_value = &thruput; |
| netperf_output_source[THROUGHPUT].max_line_len = |
| NETPERF_LINE_MAX(THROUGHPUT); |
| netperf_output_source[THROUGHPUT].tot_line_len = |
| NETPERF_LINE_TOT(THROUGHPUT); |
| |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].output_name = LOCAL_SEND_THROUGHPUT; |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].line[2] = "Throughput"; |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].format = "%.2f"; |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].display_value = &local_send_thruput; |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_THROUGHPUT); |
| netperf_output_source[LOCAL_SEND_THROUGHPUT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_THROUGHPUT); |
| |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].output_name = LOCAL_RECV_THROUGHPUT; |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].line[2] = "Throughput"; |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].format = "%.2f"; |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].display_value = &local_recv_thruput; |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_THROUGHPUT); |
| netperf_output_source[LOCAL_RECV_THROUGHPUT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_THROUGHPUT); |
| |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].output_name = REMOTE_SEND_THROUGHPUT; |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].line[2] = "Throughput"; |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].format = "%.2f"; |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].display_value = &remote_send_thruput; |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_THROUGHPUT); |
| netperf_output_source[REMOTE_SEND_THROUGHPUT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_THROUGHPUT); |
| |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].output_name = REMOTE_RECV_THROUGHPUT; |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].line[2] = "Throughput"; |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].format = "%.2f"; |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].display_value = &remote_recv_thruput; |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_THROUGHPUT); |
| netperf_output_source[REMOTE_RECV_THROUGHPUT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_THROUGHPUT); |
| |
| netperf_output_source[THROUGHPUT_UNITS].output_name = THROUGHPUT_UNITS; |
| netperf_output_source[THROUGHPUT_UNITS].line[0] = "Throughput"; |
| netperf_output_source[THROUGHPUT_UNITS].line[1] = "Units"; |
| netperf_output_source[THROUGHPUT_UNITS].format = "%s/s"; |
| netperf_output_source[THROUGHPUT_UNITS].display_value = thruput_format_str; |
| netperf_output_source[THROUGHPUT_UNITS].max_line_len = |
| NETPERF_LINE_MAX(THROUGHPUT_UNITS); |
| netperf_output_source[THROUGHPUT_UNITS].tot_line_len = |
| NETPERF_LINE_TOT(THROUGHPUT_UNITS); |
| |
| netperf_output_source[CONFIDENCE_LEVEL].output_name = CONFIDENCE_LEVEL; |
| netperf_output_source[CONFIDENCE_LEVEL].line[0] = "Confidence"; |
| netperf_output_source[CONFIDENCE_LEVEL].line[1] = "Level"; |
| netperf_output_source[CONFIDENCE_LEVEL].line[2] = "Percent"; |
| netperf_output_source[CONFIDENCE_LEVEL].format = "%d"; |
| netperf_output_source[CONFIDENCE_LEVEL].display_value = &confidence_level; |
| netperf_output_source[CONFIDENCE_LEVEL].max_line_len = |
| NETPERF_LINE_MAX(CONFIDENCE_LEVEL); |
| netperf_output_source[CONFIDENCE_LEVEL].tot_line_len = |
| NETPERF_LINE_TOT(CONFIDENCE_LEVEL); |
| |
| netperf_output_source[CONFIDENCE_INTERVAL].output_name = CONFIDENCE_INTERVAL; |
| netperf_output_source[CONFIDENCE_INTERVAL].line[0] = "Confidence"; |
| netperf_output_source[CONFIDENCE_INTERVAL].line[1] = "Width"; |
| netperf_output_source[CONFIDENCE_INTERVAL].line[2] = "Target"; |
| netperf_output_source[CONFIDENCE_INTERVAL].format = "%f"; |
| netperf_output_source[CONFIDENCE_INTERVAL].display_value = &interval_pct; |
| netperf_output_source[CONFIDENCE_INTERVAL].max_line_len = |
| NETPERF_LINE_MAX(CONFIDENCE_INTERVAL); |
| netperf_output_source[CONFIDENCE_INTERVAL].tot_line_len = |
| NETPERF_LINE_TOT(CONFIDENCE_INTERVAL); |
| |
| netperf_output_source[CONFIDENCE_ITERATION].output_name = CONFIDENCE_ITERATION; |
| netperf_output_source[CONFIDENCE_ITERATION].line[0] = "Confidence"; |
| netperf_output_source[CONFIDENCE_ITERATION].line[1] = "Iterations"; |
| netperf_output_source[CONFIDENCE_ITERATION].line[2] = "Run"; |
| netperf_output_source[CONFIDENCE_ITERATION].format = "%d"; |
| netperf_output_source[CONFIDENCE_ITERATION].display_value = &confidence_iteration; |
| netperf_output_source[CONFIDENCE_ITERATION].max_line_len = |
| NETPERF_LINE_MAX(CONFIDENCE_ITERATION); |
| netperf_output_source[CONFIDENCE_ITERATION].tot_line_len = |
| NETPERF_LINE_TOT(CONFIDENCE_ITERATION); |
| |
| netperf_output_source[THROUGHPUT_CONFID].output_name = THROUGHPUT_CONFID; |
| netperf_output_source[THROUGHPUT_CONFID].line[0] = "Throughput"; |
| netperf_output_source[THROUGHPUT_CONFID].line[1] = "Confidence"; |
| netperf_output_source[THROUGHPUT_CONFID].line[2] = "Width (%)"; |
| netperf_output_source[THROUGHPUT_CONFID].format = "%.3f"; |
| netperf_output_source[THROUGHPUT_CONFID].display_value = &result_confid_pct; |
| netperf_output_source[THROUGHPUT_CONFID].max_line_len = |
| NETPERF_LINE_MAX(THROUGHPUT_CONFID); |
| netperf_output_source[THROUGHPUT_CONFID].tot_line_len = |
| NETPERF_LINE_TOT(THROUGHPUT_CONFID); |
| |
| netperf_output_source[LOCAL_CPU_CONFID].output_name = LOCAL_CPU_CONFID; |
| netperf_output_source[LOCAL_CPU_CONFID].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_CONFID].line[1] = "CPU"; |
| netperf_output_source[LOCAL_CPU_CONFID].line[2] = "Confidence"; |
| netperf_output_source[LOCAL_CPU_CONFID].line[3] = "Width (%)"; |
| netperf_output_source[LOCAL_CPU_CONFID].format = "%.3f"; |
| netperf_output_source[LOCAL_CPU_CONFID].display_value = &loc_cpu_confid_pct; |
| netperf_output_source[LOCAL_CPU_CONFID].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_CONFID); |
| netperf_output_source[LOCAL_CPU_CONFID].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_CONFID); |
| |
| netperf_output_source[REMOTE_CPU_CONFID].output_name = REMOTE_CPU_CONFID; |
| netperf_output_source[REMOTE_CPU_CONFID].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_CONFID].line[1] = "CPU"; |
| netperf_output_source[REMOTE_CPU_CONFID].line[2] = "Confidence"; |
| netperf_output_source[REMOTE_CPU_CONFID].line[3] = "Width (%)"; |
| netperf_output_source[REMOTE_CPU_CONFID].format = "%.3f"; |
| netperf_output_source[REMOTE_CPU_CONFID].display_value = &rem_cpu_confid_pct; |
| netperf_output_source[REMOTE_CPU_CONFID].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_CONFID); |
| netperf_output_source[REMOTE_CPU_CONFID].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_CONFID); |
| |
| netperf_output_source[RT_LATENCY].output_name = RT_LATENCY; |
| netperf_output_source[RT_LATENCY].line[0] = "Round"; |
| netperf_output_source[RT_LATENCY].line[1] = "Trip"; |
| netperf_output_source[RT_LATENCY].line[2] = "Latency"; |
| netperf_output_source[RT_LATENCY].line[3] = "usec/tran"; |
| netperf_output_source[RT_LATENCY].format = "%.3f"; |
| netperf_output_source[RT_LATENCY].display_value = &rtt_latency; |
| netperf_output_source[RT_LATENCY].max_line_len = |
| NETPERF_LINE_MAX(RT_LATENCY); |
| netperf_output_source[RT_LATENCY].tot_line_len = |
| NETPERF_LINE_TOT(RT_LATENCY); |
| |
| netperf_output_source[TRANSACTION_RATE].output_name = TRANSACTION_RATE; |
| netperf_output_source[TRANSACTION_RATE].line[0] = "Transaction"; |
| netperf_output_source[TRANSACTION_RATE].line[1] = "Rate"; |
| netperf_output_source[TRANSACTION_RATE].line[2] = "Tran/s"; |
| netperf_output_source[TRANSACTION_RATE].format = "%.3f"; |
| netperf_output_source[TRANSACTION_RATE].display_value = &transaction_rate; |
| netperf_output_source[TRANSACTION_RATE].max_line_len = |
| NETPERF_LINE_MAX(TRANSACTION_RATE); |
| netperf_output_source[TRANSACTION_RATE].tot_line_len = |
| NETPERF_LINE_TOT(TRANSACTION_RATE); |
| |
| netperf_output_source[TRANSPORT_MSS].output_name = TRANSPORT_MSS; |
| netperf_output_source[TRANSPORT_MSS].line[0] = "Transport"; |
| netperf_output_source[TRANSPORT_MSS].line[1] = "MSS"; |
| netperf_output_source[TRANSPORT_MSS].line[2] = "bytes"; |
| netperf_output_source[TRANSPORT_MSS].format = "%d"; |
| netperf_output_source[TRANSPORT_MSS].display_value = &transport_mss; |
| netperf_output_source[TRANSPORT_MSS].max_line_len = |
| NETPERF_LINE_MAX(TRANSPORT_MSS); |
| netperf_output_source[TRANSPORT_MSS].tot_line_len = |
| NETPERF_LINE_TOT(TRANSPORT_MSS); |
| |
| netperf_output_source[REQUEST_SIZE].output_name = REQUEST_SIZE; |
| netperf_output_source[REQUEST_SIZE].line[0] = "Request"; |
| netperf_output_source[REQUEST_SIZE].line[1] = "Size"; |
| netperf_output_source[REQUEST_SIZE].line[2] = "Bytes"; |
| netperf_output_source[REQUEST_SIZE].format = "%d"; |
| netperf_output_source[REQUEST_SIZE].display_value = &req_size; |
| netperf_output_source[REQUEST_SIZE].max_line_len = |
| NETPERF_LINE_MAX(REQUEST_SIZE); |
| netperf_output_source[REQUEST_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(REQUEST_SIZE); |
| |
| netperf_output_source[RESPONSE_SIZE].output_name = RESPONSE_SIZE; |
| netperf_output_source[RESPONSE_SIZE].line[0] = "Response"; |
| netperf_output_source[RESPONSE_SIZE].line[1] = "Size"; |
| netperf_output_source[RESPONSE_SIZE].line[2] = "Bytes"; |
| netperf_output_source[RESPONSE_SIZE].format = "%d"; |
| netperf_output_source[RESPONSE_SIZE].display_value = &rsp_size; |
| netperf_output_source[RESPONSE_SIZE].max_line_len = |
| NETPERF_LINE_MAX(RESPONSE_SIZE); |
| netperf_output_source[RESPONSE_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(RESPONSE_SIZE); |
| |
| netperf_output_source[BURST_SIZE].output_name = BURST_SIZE; |
| netperf_output_source[BURST_SIZE].line[0] = "Initial"; |
| netperf_output_source[BURST_SIZE].line[1] = "Burst"; |
| netperf_output_source[BURST_SIZE].line[2] = "Requests"; |
| netperf_output_source[BURST_SIZE].format = "%d"; |
| netperf_output_source[BURST_SIZE].display_value = &first_burst_size; |
| netperf_output_source[BURST_SIZE].max_line_len = |
| NETPERF_LINE_MAX(BURST_SIZE); |
| netperf_output_source[BURST_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(BURST_SIZE); |
| |
| netperf_output_source[LSS_SIZE_REQ].output_name = LSS_SIZE_REQ; |
| netperf_output_source[LSS_SIZE_REQ].line[0] = "Local"; |
| netperf_output_source[LSS_SIZE_REQ].line[1] = "Send Socket"; |
| netperf_output_source[LSS_SIZE_REQ].line[2] = "Size"; |
| netperf_output_source[LSS_SIZE_REQ].line[3] = "Requested"; |
| netperf_output_source[LSS_SIZE_REQ].format = "%d"; |
| netperf_output_source[LSS_SIZE_REQ].display_value = &lss_size_req; |
| netperf_output_source[LSS_SIZE_REQ].max_line_len = |
| NETPERF_LINE_MAX(LSS_SIZE_REQ); |
| netperf_output_source[LSS_SIZE_REQ].tot_line_len = |
| NETPERF_LINE_TOT(LSS_SIZE_REQ); |
| |
| netperf_output_source[LSS_SIZE].output_name = LSS_SIZE; |
| netperf_output_source[LSS_SIZE].line[0] = "Local"; |
| netperf_output_source[LSS_SIZE].line[1] = "Send Socket"; |
| netperf_output_source[LSS_SIZE].line[2] = "Size"; |
| netperf_output_source[LSS_SIZE].line[3] = "Initial"; |
| netperf_output_source[LSS_SIZE].format = "%d"; |
| netperf_output_source[LSS_SIZE].display_value = &lss_size; |
| netperf_output_source[LSS_SIZE].max_line_len = |
| NETPERF_LINE_MAX(LSS_SIZE); |
| netperf_output_source[LSS_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(LSS_SIZE); |
| |
| netperf_output_source[LSS_SIZE_END].output_name = LSS_SIZE_END; |
| netperf_output_source[LSS_SIZE_END].line[0] = "Local"; |
| netperf_output_source[LSS_SIZE_END].line[1] = "Send Socket"; |
| netperf_output_source[LSS_SIZE_END].line[2] = "Size"; |
| netperf_output_source[LSS_SIZE_END].line[3] = "Final"; |
| netperf_output_source[LSS_SIZE_END].format = "%d"; |
| netperf_output_source[LSS_SIZE_END].display_value = &lss_size_end; |
| netperf_output_source[LSS_SIZE_END].max_line_len = |
| NETPERF_LINE_MAX(LSS_SIZE_END); |
| netperf_output_source[LSS_SIZE_END].tot_line_len = |
| NETPERF_LINE_TOT(LSS_SIZE_END); |
| |
| netperf_output_source[LSR_SIZE_REQ].output_name = LSR_SIZE_REQ; |
| netperf_output_source[LSR_SIZE_REQ].line[0] = "Local"; |
| netperf_output_source[LSR_SIZE_REQ].line[1] = "Recv Socket"; |
| netperf_output_source[LSR_SIZE_REQ].line[2] = "Size"; |
| netperf_output_source[LSR_SIZE_REQ].line[3] = "Requested"; |
| netperf_output_source[LSR_SIZE_REQ].format = "%d"; |
| netperf_output_source[LSR_SIZE_REQ].display_value = &lsr_size_req; |
| netperf_output_source[LSR_SIZE_REQ].max_line_len = |
| NETPERF_LINE_MAX(LSR_SIZE_REQ); |
| netperf_output_source[LSR_SIZE_REQ].tot_line_len = |
| NETPERF_LINE_TOT(LSR_SIZE_REQ); |
| |
| netperf_output_source[LSR_SIZE].output_name = LSR_SIZE; |
| netperf_output_source[LSR_SIZE].line[0] = "Local"; |
| netperf_output_source[LSR_SIZE].line[1] = "Recv Socket"; |
| netperf_output_source[LSR_SIZE].line[2] = "Size"; |
| netperf_output_source[LSR_SIZE].line[3] = "Initial"; |
| netperf_output_source[LSR_SIZE].format = "%d"; |
| netperf_output_source[LSR_SIZE].display_value = &lsr_size; |
| netperf_output_source[LSR_SIZE].max_line_len = |
| NETPERF_LINE_MAX(LSR_SIZE); |
| netperf_output_source[LSR_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(LSR_SIZE); |
| |
| netperf_output_source[LSR_SIZE_END].output_name = LSR_SIZE_END; |
| netperf_output_source[LSR_SIZE_END].line[0] = "Local"; |
| netperf_output_source[LSR_SIZE_END].line[1] = "Recv Socket"; |
| netperf_output_source[LSR_SIZE_END].line[2] = "Size"; |
| netperf_output_source[LSR_SIZE_END].line[3] = "Final"; |
| netperf_output_source[LSR_SIZE_END].format = "%d"; |
| netperf_output_source[LSR_SIZE_END].display_value = &lsr_size_end; |
| netperf_output_source[LSR_SIZE_END].max_line_len = |
| NETPERF_LINE_MAX(LSR_SIZE_END); |
| netperf_output_source[LSR_SIZE_END].tot_line_len = |
| NETPERF_LINE_TOT(LSR_SIZE_END); |
| |
| netperf_output_source[LOCAL_SEND_SIZE].output_name = LOCAL_SEND_SIZE; |
| netperf_output_source[LOCAL_SEND_SIZE].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_SIZE].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_SIZE].line[2] = "Size"; |
| netperf_output_source[LOCAL_SEND_SIZE].line[3] = ""; |
| netperf_output_source[LOCAL_SEND_SIZE].format = "%d"; |
| netperf_output_source[LOCAL_SEND_SIZE].display_value = &send_size; |
| netperf_output_source[LOCAL_SEND_SIZE].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_SIZE); |
| netperf_output_source[LOCAL_SEND_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_SIZE); |
| |
| netperf_output_source[LOCAL_RECV_SIZE].output_name = LOCAL_RECV_SIZE; |
| netperf_output_source[LOCAL_RECV_SIZE].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_SIZE].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_SIZE].line[2] = "Size"; |
| netperf_output_source[LOCAL_RECV_SIZE].line[3] = ""; |
| netperf_output_source[LOCAL_RECV_SIZE].format = "%d"; |
| netperf_output_source[LOCAL_RECV_SIZE].display_value = &recv_size; |
| netperf_output_source[LOCAL_RECV_SIZE].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_SIZE); |
| netperf_output_source[LOCAL_RECV_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_SIZE); |
| |
| netperf_output_source[LOCAL_SEND_CALLS].output_name = LOCAL_SEND_CALLS; |
| netperf_output_source[LOCAL_SEND_CALLS].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_CALLS].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_CALLS].line[2] = "Calls"; |
| netperf_output_source[LOCAL_SEND_CALLS].line[3] = ""; |
| netperf_output_source[LOCAL_SEND_CALLS].format = "%d"; |
| netperf_output_source[LOCAL_SEND_CALLS].display_value = &local_send_calls; |
| netperf_output_source[LOCAL_SEND_CALLS].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_CALLS); |
| netperf_output_source[LOCAL_SEND_CALLS].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_CALLS); |
| |
| netperf_output_source[LOCAL_RECV_CALLS].output_name = LOCAL_RECV_CALLS; |
| netperf_output_source[LOCAL_RECV_CALLS].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_CALLS].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_CALLS].line[2] = "Calls"; |
| netperf_output_source[LOCAL_RECV_CALLS].line[3] = ""; |
| netperf_output_source[LOCAL_RECV_CALLS].format = "%d"; |
| netperf_output_source[LOCAL_RECV_CALLS].display_value = &local_receive_calls; |
| netperf_output_source[LOCAL_RECV_CALLS].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_CALLS); |
| netperf_output_source[LOCAL_RECV_CALLS].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_CALLS); |
| |
| netperf_output_source[LOCAL_BYTES_PER_RECV].output_name = LOCAL_BYTES_PER_RECV; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].line[0] = "Local"; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].line[1] = "Bytes"; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].line[2] = "Per"; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].line[3] = "Recv"; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].format = "%.2f"; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].display_value = &bytes_per_recv; |
| netperf_output_source[LOCAL_BYTES_PER_RECV].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_BYTES_PER_RECV); |
| netperf_output_source[LOCAL_BYTES_PER_RECV].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_BYTES_PER_RECV); |
| |
| netperf_output_source[LOCAL_BYTES_PER_SEND].output_name = LOCAL_BYTES_PER_SEND; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].line[0] = "Local"; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].line[1] = "Bytes"; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].line[2] = "Per"; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].line[3] = "Send"; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].format = "%.2f"; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].display_value = &bytes_per_send; |
| netperf_output_source[LOCAL_BYTES_PER_SEND].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_BYTES_PER_SEND); |
| netperf_output_source[LOCAL_BYTES_PER_SEND].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_BYTES_PER_SEND); |
| |
| netperf_output_source[LOCAL_BYTES_RECVD].output_name = LOCAL_BYTES_RECVD; |
| netperf_output_source[LOCAL_BYTES_RECVD].line[0] = "Local"; |
| netperf_output_source[LOCAL_BYTES_RECVD].line[1] = "Bytes"; |
| netperf_output_source[LOCAL_BYTES_RECVD].line[2] = "Received"; |
| netperf_output_source[LOCAL_BYTES_RECVD].line[3] = ""; |
| netperf_output_source[LOCAL_BYTES_RECVD].format = "%lld"; |
| netperf_output_source[LOCAL_BYTES_RECVD].display_value = &bytes_received; |
| netperf_output_source[LOCAL_BYTES_RECVD].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_BYTES_RECVD); |
| netperf_output_source[LOCAL_BYTES_RECVD].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_BYTES_RECVD); |
| |
| netperf_output_source[LOCAL_BYTES_SENT].output_name = LOCAL_BYTES_SENT; |
| netperf_output_source[LOCAL_BYTES_SENT].line[0] = "Local"; |
| netperf_output_source[LOCAL_BYTES_SENT].line[1] = "Bytes"; |
| netperf_output_source[LOCAL_BYTES_SENT].line[2] = "Sent"; |
| netperf_output_source[LOCAL_BYTES_SENT].line[3] = ""; |
| netperf_output_source[LOCAL_BYTES_SENT].format = "%lld"; |
| netperf_output_source[LOCAL_BYTES_SENT].display_value = &bytes_sent; |
| netperf_output_source[LOCAL_BYTES_SENT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_BYTES_SENT); |
| netperf_output_source[LOCAL_BYTES_SENT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_BYTES_SENT); |
| |
| netperf_output_source[LOCAL_BYTES_XFERD].output_name = LOCAL_BYTES_XFERD; |
| netperf_output_source[LOCAL_BYTES_XFERD].line[0] = "Local"; |
| netperf_output_source[LOCAL_BYTES_XFERD].line[1] = "Bytes"; |
| netperf_output_source[LOCAL_BYTES_XFERD].line[2] = "Xferred"; |
| netperf_output_source[LOCAL_BYTES_XFERD].line[3] = ""; |
| netperf_output_source[LOCAL_BYTES_XFERD].format = "%.0f"; |
| netperf_output_source[LOCAL_BYTES_XFERD].display_value = &bytes_xferd; |
| netperf_output_source[LOCAL_BYTES_XFERD].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_BYTES_XFERD); |
| netperf_output_source[LOCAL_BYTES_XFERD].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_BYTES_XFERD); |
| |
| netperf_output_source[LOCAL_SEND_WIDTH].output_name = LOCAL_SEND_WIDTH; |
| netperf_output_source[LOCAL_SEND_WIDTH].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_WIDTH].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_WIDTH].line[2] = "Width"; |
| netperf_output_source[LOCAL_SEND_WIDTH].format = "%d"; |
| netperf_output_source[LOCAL_SEND_WIDTH].display_value = &send_width; |
| netperf_output_source[LOCAL_SEND_WIDTH].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_WIDTH); |
| netperf_output_source[LOCAL_SEND_WIDTH].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_WIDTH); |
| |
| netperf_output_source[LOCAL_RECV_WIDTH].output_name = LOCAL_RECV_WIDTH; |
| netperf_output_source[LOCAL_RECV_WIDTH].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_WIDTH].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_WIDTH].line[2] = "Width"; |
| netperf_output_source[LOCAL_RECV_WIDTH].format = "%d"; |
| netperf_output_source[LOCAL_RECV_WIDTH].display_value = &recv_width; |
| netperf_output_source[LOCAL_RECV_WIDTH].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_WIDTH); |
| netperf_output_source[LOCAL_RECV_WIDTH].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_WIDTH); |
| |
| netperf_output_source[LOCAL_SEND_OFFSET].output_name = LOCAL_SEND_OFFSET; |
| netperf_output_source[LOCAL_SEND_OFFSET].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_OFFSET].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_OFFSET].line[2] = "Offset"; |
| netperf_output_source[LOCAL_SEND_OFFSET].format = "%d"; |
| netperf_output_source[LOCAL_SEND_OFFSET].display_value = &local_send_offset; |
| netperf_output_source[LOCAL_SEND_OFFSET].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_OFFSET); |
| netperf_output_source[LOCAL_SEND_OFFSET].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_OFFSET); |
| |
| netperf_output_source[LOCAL_RECV_OFFSET].output_name = LOCAL_RECV_OFFSET; |
| netperf_output_source[LOCAL_RECV_OFFSET].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_OFFSET].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_OFFSET].line[2] = "Offset"; |
| netperf_output_source[LOCAL_RECV_OFFSET].format = "%d"; |
| netperf_output_source[LOCAL_RECV_OFFSET].display_value = &local_recv_offset; |
| netperf_output_source[LOCAL_RECV_OFFSET].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_OFFSET); |
| netperf_output_source[LOCAL_RECV_OFFSET].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_OFFSET); |
| |
| netperf_output_source[LOCAL_RECV_ALIGN].output_name = LOCAL_RECV_ALIGN; |
| netperf_output_source[LOCAL_RECV_ALIGN].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_ALIGN].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_ALIGN].line[2] = "Alignment"; |
| netperf_output_source[LOCAL_RECV_ALIGN].format = "%d"; |
| netperf_output_source[LOCAL_RECV_ALIGN].display_value = &local_recv_align; |
| netperf_output_source[LOCAL_RECV_ALIGN].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_ALIGN); |
| netperf_output_source[LOCAL_RECV_ALIGN].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_ALIGN); |
| |
| netperf_output_source[LOCAL_SEND_ALIGN].output_name = LOCAL_SEND_ALIGN; |
| netperf_output_source[LOCAL_SEND_ALIGN].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_ALIGN].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_ALIGN].line[2] = "Alignment"; |
| netperf_output_source[LOCAL_SEND_ALIGN].format = "%d"; |
| netperf_output_source[LOCAL_SEND_ALIGN].display_value = &local_send_align; |
| netperf_output_source[LOCAL_SEND_ALIGN].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_ALIGN); |
| netperf_output_source[LOCAL_SEND_ALIGN].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_ALIGN); |
| |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].output_name = LOCAL_SEND_DIRTY_COUNT; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[0] = "Local"; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[1] = "Send"; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[2] = "Dirty"; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].line[3] = "Count"; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].format = "%d"; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].display_value = &loc_dirty_count; |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SEND_DIRTY_COUNT); |
| netperf_output_source[LOCAL_SEND_DIRTY_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SEND_DIRTY_COUNT); |
| |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].output_name = LOCAL_RECV_DIRTY_COUNT; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[2] = "Dirty"; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].line[3] = "Count"; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].format = "%d"; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].display_value = &loc_dirty_count; |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_DIRTY_COUNT); |
| netperf_output_source[LOCAL_RECV_DIRTY_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_DIRTY_COUNT); |
| |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].output_name = LOCAL_RECV_CLEAN_COUNT; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[0] = "Local"; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[1] = "Recv"; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[2] = "Clean"; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].line[3] = "Count"; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].format = "%d"; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].display_value = &loc_clean_count; |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_RECV_CLEAN_COUNT); |
| netperf_output_source[LOCAL_RECV_CLEAN_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_RECV_CLEAN_COUNT); |
| |
| netperf_output_source[LOCAL_CPU_UTIL].output_name = LOCAL_CPU_UTIL; |
| netperf_output_source[LOCAL_CPU_UTIL].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_UTIL].line[1] = "CPU"; |
| netperf_output_source[LOCAL_CPU_UTIL].line[2] = "Util"; |
| netperf_output_source[LOCAL_CPU_UTIL].line[3] = "%"; |
| netperf_output_source[LOCAL_CPU_UTIL].format = "%.2f"; |
| netperf_output_source[LOCAL_CPU_UTIL].display_value = &local_cpu_utilization_double; |
| netperf_output_source[LOCAL_CPU_UTIL].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_UTIL); |
| netperf_output_source[LOCAL_CPU_UTIL].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_UTIL); |
| |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].output_name = LOCAL_CPU_PEAK_UTIL; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[1] = "Peak"; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[2] = "Per CPU"; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].line[3] = "Util %"; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].format = "%.2f"; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].display_value = &lib_local_peak_cpu_util; |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_PEAK_UTIL); |
| netperf_output_source[LOCAL_CPU_PEAK_UTIL].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_PEAK_UTIL); |
| |
| netperf_output_source[LOCAL_CPU_PEAK_ID].output_name = LOCAL_CPU_PEAK_ID; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].line[1] = "Peak"; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].line[2] = "Per CPU"; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].line[3] = "ID"; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].format = "%d"; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].display_value = &lib_local_peak_cpu_id; |
| netperf_output_source[LOCAL_CPU_PEAK_ID].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_PEAK_ID); |
| netperf_output_source[LOCAL_CPU_PEAK_ID].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_PEAK_ID); |
| |
| netperf_output_source[LOCAL_CPU_BIND].output_name = LOCAL_CPU_BIND; |
| netperf_output_source[LOCAL_CPU_BIND].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_BIND].line[1] = "CPU"; |
| netperf_output_source[LOCAL_CPU_BIND].line[2] = "Bind"; |
| netperf_output_source[LOCAL_CPU_BIND].line[3] = ""; |
| netperf_output_source[LOCAL_CPU_BIND].format = "%d"; |
| netperf_output_source[LOCAL_CPU_BIND].display_value = &local_proc_affinity; |
| netperf_output_source[LOCAL_CPU_BIND].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_BIND); |
| netperf_output_source[LOCAL_CPU_BIND].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_BIND); |
| |
| netperf_output_source[LOCAL_SD].output_name = LOCAL_SD; |
| netperf_output_source[LOCAL_SD].line[0] = "Local"; |
| netperf_output_source[LOCAL_SD].line[1] = "Service"; |
| netperf_output_source[LOCAL_SD].line[2] = "Demand"; |
| netperf_output_source[LOCAL_SD].line[3] = ""; |
| netperf_output_source[LOCAL_SD].format = "%.3f"; |
| netperf_output_source[LOCAL_SD].display_value = &local_service_demand_double; |
| netperf_output_source[LOCAL_SD].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_SD); |
| netperf_output_source[LOCAL_SD].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_SD); |
| |
| netperf_output_source[SD_UNITS].output_name = SD_UNITS; |
| netperf_output_source[SD_UNITS].line[0] = "Service"; |
| netperf_output_source[SD_UNITS].line[1] = "Demand"; |
| netperf_output_source[SD_UNITS].line[2] = "Units"; |
| netperf_output_source[SD_UNITS].format = "%s"; |
| netperf_output_source[SD_UNITS].display_value = sd_str; |
| netperf_output_source[SD_UNITS].max_line_len = |
| NETPERF_LINE_MAX(SD_UNITS); |
| netperf_output_source[SD_UNITS].tot_line_len = |
| NETPERF_LINE_TOT(SD_UNITS); |
| |
| netperf_output_source[LOCAL_CPU_METHOD].output_name = LOCAL_CPU_METHOD; |
| netperf_output_source[LOCAL_CPU_METHOD].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_METHOD].line[1] = "CPU"; |
| netperf_output_source[LOCAL_CPU_METHOD].line[2] = "Util"; |
| netperf_output_source[LOCAL_CPU_METHOD].line[3] = "Method"; |
| netperf_output_source[LOCAL_CPU_METHOD].format = "%c"; |
| netperf_output_source[LOCAL_CPU_METHOD].display_value = &local_cpu_method; |
| netperf_output_source[LOCAL_CPU_METHOD].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_METHOD); |
| netperf_output_source[LOCAL_CPU_METHOD].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_METHOD); |
| |
| netperf_output_source[LOCAL_CPU_COUNT].output_name = LOCAL_CPU_COUNT; |
| netperf_output_source[LOCAL_CPU_COUNT].line[0] = "Local"; |
| netperf_output_source[LOCAL_CPU_COUNT].line[1] = "CPU"; |
| netperf_output_source[LOCAL_CPU_COUNT].line[2] = "Count"; |
| netperf_output_source[LOCAL_CPU_COUNT].format = "%d"; |
| netperf_output_source[LOCAL_CPU_COUNT].display_value = &lib_num_loc_cpus; |
| netperf_output_source[LOCAL_CPU_COUNT].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CPU_COUNT); |
| netperf_output_source[LOCAL_CPU_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CPU_COUNT); |
| |
| netperf_output_source[LOCAL_NODELAY].output_name = LOCAL_NODELAY; |
| netperf_output_source[LOCAL_NODELAY].line[0] = "Local"; |
| netperf_output_source[LOCAL_NODELAY].line[1] = "NODELAY"; |
| netperf_output_source[LOCAL_NODELAY].line[2] = ""; |
| netperf_output_source[LOCAL_NODELAY].line[3] = ""; |
| netperf_output_source[LOCAL_NODELAY].format = "%d"; |
| netperf_output_source[LOCAL_NODELAY].display_value = &loc_nodelay; |
| netperf_output_source[LOCAL_NODELAY].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_NODELAY); |
| netperf_output_source[LOCAL_NODELAY].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_NODELAY); |
| |
| netperf_output_source[LOCAL_CORK].output_name = LOCAL_CORK; |
| netperf_output_source[LOCAL_CORK].line[0] = "Local"; |
| netperf_output_source[LOCAL_CORK].line[1] = "Cork"; |
| netperf_output_source[LOCAL_CORK].line[2] = ""; |
| netperf_output_source[LOCAL_CORK].line[3] = ""; |
| netperf_output_source[LOCAL_CORK].format = "%d"; |
| netperf_output_source[LOCAL_CORK].display_value = &loc_tcpcork; |
| netperf_output_source[LOCAL_CORK].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_CORK); |
| netperf_output_source[LOCAL_CORK].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_CORK); |
| |
| netperf_output_source[RSS_SIZE_REQ].output_name = RSS_SIZE_REQ; |
| netperf_output_source[RSS_SIZE_REQ].line[0] = "Remote"; |
| netperf_output_source[RSS_SIZE_REQ].line[1] = "Send Socket"; |
| netperf_output_source[RSS_SIZE_REQ].line[2] = "Size"; |
| netperf_output_source[RSS_SIZE_REQ].line[3] = "Requested"; |
| netperf_output_source[RSS_SIZE_REQ].format = "%d"; |
| netperf_output_source[RSS_SIZE_REQ].display_value = &rss_size_req; |
| netperf_output_source[RSS_SIZE_REQ].max_line_len = |
| NETPERF_LINE_MAX(RSS_SIZE_REQ); |
| netperf_output_source[RSS_SIZE_REQ].tot_line_len = |
| NETPERF_LINE_TOT(RSS_SIZE_REQ); |
| |
| netperf_output_source[RSS_SIZE].output_name = RSS_SIZE; |
| netperf_output_source[RSS_SIZE].line[0] = "Remote"; |
| netperf_output_source[RSS_SIZE].line[1] = "Send Socket"; |
| netperf_output_source[RSS_SIZE].line[2] = "Size"; |
| netperf_output_source[RSS_SIZE].line[3] = "Initial"; |
| netperf_output_source[RSS_SIZE].format = "%d"; |
| netperf_output_source[RSS_SIZE].display_value = &rss_size; |
| netperf_output_source[RSS_SIZE].max_line_len = |
| NETPERF_LINE_MAX(RSS_SIZE); |
| netperf_output_source[RSS_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(RSS_SIZE); |
| |
| netperf_output_source[RSS_SIZE_END].output_name = RSS_SIZE_END; |
| netperf_output_source[RSS_SIZE_END].line[0] = "Remote"; |
| netperf_output_source[RSS_SIZE_END].line[1] = "Send Socket"; |
| netperf_output_source[RSS_SIZE_END].line[2] = "Size"; |
| netperf_output_source[RSS_SIZE_END].line[3] = "Final"; |
| netperf_output_source[RSS_SIZE_END].format = "%d"; |
| netperf_output_source[RSS_SIZE_END].display_value = &rss_size_end; |
| netperf_output_source[RSS_SIZE_END].max_line_len = |
| NETPERF_LINE_MAX(RSS_SIZE_END); |
| netperf_output_source[RSS_SIZE_END].tot_line_len = |
| NETPERF_LINE_TOT(RSS_SIZE_END); |
| |
| netperf_output_source[RSR_SIZE_REQ].output_name = RSR_SIZE_REQ; |
| netperf_output_source[RSR_SIZE_REQ].line[0] = "Remote"; |
| netperf_output_source[RSR_SIZE_REQ].line[1] = "Recv Socket"; |
| netperf_output_source[RSR_SIZE_REQ].line[2] = "Size"; |
| netperf_output_source[RSR_SIZE_REQ].line[3] = "Requested"; |
| netperf_output_source[RSR_SIZE_REQ].format = "%d"; |
| netperf_output_source[RSR_SIZE_REQ].display_value = &rsr_size_req; |
| netperf_output_source[RSR_SIZE_REQ].max_line_len = |
| NETPERF_LINE_MAX(RSR_SIZE_REQ); |
| netperf_output_source[RSR_SIZE_REQ].tot_line_len = |
| NETPERF_LINE_TOT(RSR_SIZE_REQ); |
| |
| netperf_output_source[RSR_SIZE].output_name = RSR_SIZE; |
| netperf_output_source[RSR_SIZE].line[0] = "Remote"; |
| netperf_output_source[RSR_SIZE].line[1] = "Recv Socket"; |
| netperf_output_source[RSR_SIZE].line[2] = "Size"; |
| netperf_output_source[RSR_SIZE].line[3] = "Initial"; |
| netperf_output_source[RSR_SIZE].format = "%d"; |
| netperf_output_source[RSR_SIZE].display_value = &rsr_size; |
| netperf_output_source[RSR_SIZE].max_line_len = |
| NETPERF_LINE_MAX(RSR_SIZE); |
| netperf_output_source[RSR_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(RSR_SIZE); |
| |
| netperf_output_source[RSR_SIZE_END].output_name = RSR_SIZE_END; |
| netperf_output_source[RSR_SIZE_END].line[0] = "Remote"; |
| netperf_output_source[RSR_SIZE_END].line[1] = "Recv Socket"; |
| netperf_output_source[RSR_SIZE_END].line[2] = "Size"; |
| netperf_output_source[RSR_SIZE_END].line[3] = "Final"; |
| netperf_output_source[RSR_SIZE_END].format = "%d"; |
| netperf_output_source[RSR_SIZE_END].display_value = &rsr_size_end; |
| netperf_output_source[RSR_SIZE_END].max_line_len = |
| NETPERF_LINE_MAX(RSR_SIZE_END); |
| netperf_output_source[RSR_SIZE_END].tot_line_len = |
| NETPERF_LINE_TOT(RSR_SIZE_END); |
| |
| netperf_output_source[REMOTE_SEND_SIZE].output_name = REMOTE_SEND_SIZE; |
| netperf_output_source[REMOTE_SEND_SIZE].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_SIZE].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_SIZE].line[2] = "Size"; |
| netperf_output_source[REMOTE_SEND_SIZE].line[3] = ""; |
| netperf_output_source[REMOTE_SEND_SIZE].format = "%d"; |
| netperf_output_source[REMOTE_SEND_SIZE].display_value = &remote_send_size; |
| netperf_output_source[REMOTE_SEND_SIZE].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_SIZE); |
| netperf_output_source[REMOTE_SEND_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_SIZE); |
| |
| netperf_output_source[REMOTE_RECV_SIZE].output_name = REMOTE_RECV_SIZE; |
| netperf_output_source[REMOTE_RECV_SIZE].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_SIZE].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_SIZE].line[2] = "Size"; |
| netperf_output_source[REMOTE_RECV_SIZE].line[3] = ""; |
| netperf_output_source[REMOTE_RECV_SIZE].format = "%d"; |
| netperf_output_source[REMOTE_RECV_SIZE].display_value = &remote_recv_size; |
| netperf_output_source[REMOTE_RECV_SIZE].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_SIZE); |
| netperf_output_source[REMOTE_RECV_SIZE].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_SIZE); |
| |
| netperf_output_source[REMOTE_SEND_CALLS].output_name = REMOTE_SEND_CALLS; |
| netperf_output_source[REMOTE_SEND_CALLS].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_CALLS].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_CALLS].line[2] = "Calls"; |
| netperf_output_source[REMOTE_SEND_CALLS].line[3] = ""; |
| netperf_output_source[REMOTE_SEND_CALLS].format = "%lld"; |
| netperf_output_source[REMOTE_SEND_CALLS].display_value = &remote_send_calls; |
| netperf_output_source[REMOTE_SEND_CALLS].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_CALLS); |
| netperf_output_source[REMOTE_SEND_CALLS].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_CALLS); |
| |
| netperf_output_source[REMOTE_RECV_CALLS].output_name = REMOTE_RECV_CALLS; |
| netperf_output_source[REMOTE_RECV_CALLS].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_CALLS].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_CALLS].line[2] = "Calls"; |
| netperf_output_source[REMOTE_RECV_CALLS].line[3] = ""; |
| netperf_output_source[REMOTE_RECV_CALLS].format = "%lld"; |
| netperf_output_source[REMOTE_RECV_CALLS].display_value = &remote_receive_calls; |
| netperf_output_source[REMOTE_RECV_CALLS].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_CALLS); |
| netperf_output_source[REMOTE_RECV_CALLS].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_CALLS); |
| |
| netperf_output_source[REMOTE_BYTES_PER_RECV].output_name = REMOTE_BYTES_PER_RECV; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].line[0] = "Remote"; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].line[1] = "Bytes"; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].line[2] = "Per"; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].line[3] = "Recv"; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].format = "%.2f"; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].display_value = &remote_bytes_per_recv; |
| netperf_output_source[REMOTE_BYTES_PER_RECV].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_BYTES_PER_RECV); |
| netperf_output_source[REMOTE_BYTES_PER_RECV].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_BYTES_PER_RECV); |
| |
| netperf_output_source[REMOTE_BYTES_PER_SEND].output_name = REMOTE_BYTES_PER_SEND; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].line[0] = "Remote"; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].line[1] = "Bytes"; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].line[2] = "Per"; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].line[3] = "Send"; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].format = "%.2f"; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].display_value = &remote_bytes_per_send; |
| netperf_output_source[REMOTE_BYTES_PER_SEND].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_BYTES_PER_SEND); |
| netperf_output_source[REMOTE_BYTES_PER_SEND].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_BYTES_PER_SEND); |
| |
| netperf_output_source[REMOTE_BYTES_RECVD].output_name = REMOTE_BYTES_RECVD; |
| netperf_output_source[REMOTE_BYTES_RECVD].line[0] = "Remote"; |
| netperf_output_source[REMOTE_BYTES_RECVD].line[1] = "Bytes"; |
| netperf_output_source[REMOTE_BYTES_RECVD].line[2] = "Received"; |
| netperf_output_source[REMOTE_BYTES_RECVD].line[3] = ""; |
| netperf_output_source[REMOTE_BYTES_RECVD].format = "%lld"; |
| netperf_output_source[REMOTE_BYTES_RECVD].display_value = &remote_bytes_received; |
| netperf_output_source[REMOTE_BYTES_RECVD].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_BYTES_RECVD); |
| netperf_output_source[REMOTE_BYTES_RECVD].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_BYTES_RECVD); |
| |
| netperf_output_source[REMOTE_BYTES_SENT].output_name = REMOTE_BYTES_SENT; |
| netperf_output_source[REMOTE_BYTES_SENT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_BYTES_SENT].line[1] = "Bytes"; |
| netperf_output_source[REMOTE_BYTES_SENT].line[2] = "Sent"; |
| netperf_output_source[REMOTE_BYTES_SENT].line[3] = ""; |
| netperf_output_source[REMOTE_BYTES_SENT].format = "%lld"; |
| netperf_output_source[REMOTE_BYTES_SENT].display_value = &remote_bytes_sent; |
| netperf_output_source[REMOTE_BYTES_SENT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_BYTES_SENT); |
| netperf_output_source[REMOTE_BYTES_SENT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_BYTES_SENT); |
| |
| netperf_output_source[REMOTE_BYTES_XFERD].output_name = REMOTE_BYTES_XFERD; |
| netperf_output_source[REMOTE_BYTES_XFERD].line[0] = "Remote"; |
| netperf_output_source[REMOTE_BYTES_XFERD].line[1] = "Bytes"; |
| netperf_output_source[REMOTE_BYTES_XFERD].line[2] = "Xferred"; |
| netperf_output_source[REMOTE_BYTES_XFERD].line[3] = ""; |
| netperf_output_source[REMOTE_BYTES_XFERD].format = "%.0f"; |
| netperf_output_source[REMOTE_BYTES_XFERD].display_value = &remote_bytes_xferd; |
| netperf_output_source[REMOTE_BYTES_XFERD].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_BYTES_XFERD); |
| netperf_output_source[REMOTE_BYTES_XFERD].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_BYTES_XFERD); |
| |
| netperf_output_source[REMOTE_SEND_WIDTH].output_name = REMOTE_SEND_WIDTH; |
| netperf_output_source[REMOTE_SEND_WIDTH].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_WIDTH].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_WIDTH].line[2] = "Width"; |
| netperf_output_source[REMOTE_SEND_WIDTH].format = "%d"; |
| netperf_output_source[REMOTE_SEND_WIDTH].display_value = &remote_send_width; |
| netperf_output_source[REMOTE_SEND_WIDTH].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_WIDTH); |
| netperf_output_source[REMOTE_SEND_WIDTH].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_WIDTH); |
| |
| netperf_output_source[REMOTE_RECV_WIDTH].output_name = REMOTE_RECV_WIDTH; |
| netperf_output_source[REMOTE_RECV_WIDTH].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_WIDTH].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_WIDTH].line[2] = "Width"; |
| netperf_output_source[REMOTE_RECV_WIDTH].format = "%d"; |
| netperf_output_source[REMOTE_RECV_WIDTH].display_value = &remote_recv_width; |
| netperf_output_source[REMOTE_RECV_WIDTH].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_WIDTH); |
| netperf_output_source[REMOTE_RECV_WIDTH].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_WIDTH); |
| |
| netperf_output_source[REMOTE_SEND_OFFSET].output_name = REMOTE_SEND_OFFSET; |
| netperf_output_source[REMOTE_SEND_OFFSET].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_OFFSET].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_OFFSET].line[2] = "Offset"; |
| netperf_output_source[REMOTE_SEND_OFFSET].format = "%d"; |
| netperf_output_source[REMOTE_SEND_OFFSET].display_value = &remote_send_offset; |
| netperf_output_source[REMOTE_SEND_OFFSET].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_OFFSET); |
| netperf_output_source[REMOTE_SEND_OFFSET].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_OFFSET); |
| |
| netperf_output_source[REMOTE_RECV_OFFSET].output_name = REMOTE_RECV_OFFSET; |
| netperf_output_source[REMOTE_RECV_OFFSET].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_OFFSET].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_OFFSET].line[2] = "Offset"; |
| netperf_output_source[REMOTE_RECV_OFFSET].format = "%d"; |
| netperf_output_source[REMOTE_RECV_OFFSET].display_value = &remote_recv_offset; |
| netperf_output_source[REMOTE_RECV_OFFSET].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_OFFSET); |
| netperf_output_source[REMOTE_RECV_OFFSET].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_OFFSET); |
| |
| netperf_output_source[REMOTE_RECV_ALIGN].output_name = REMOTE_RECV_ALIGN; |
| netperf_output_source[REMOTE_RECV_ALIGN].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_ALIGN].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_ALIGN].line[2] = "Alignment"; |
| netperf_output_source[REMOTE_RECV_ALIGN].format = "%d"; |
| netperf_output_source[REMOTE_RECV_ALIGN].display_value = &remote_recv_align; |
| netperf_output_source[REMOTE_RECV_ALIGN].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_ALIGN); |
| netperf_output_source[REMOTE_RECV_ALIGN].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_ALIGN); |
| |
| netperf_output_source[REMOTE_SEND_ALIGN].output_name = REMOTE_SEND_ALIGN; |
| netperf_output_source[REMOTE_SEND_ALIGN].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_ALIGN].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_ALIGN].line[2] = "Alignment"; |
| netperf_output_source[REMOTE_SEND_ALIGN].format = "%d"; |
| netperf_output_source[REMOTE_SEND_ALIGN].display_value = &remote_send_align; |
| netperf_output_source[REMOTE_SEND_ALIGN].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_ALIGN); |
| netperf_output_source[REMOTE_SEND_ALIGN].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_ALIGN); |
| |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].output_name = REMOTE_SEND_DIRTY_COUNT; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[1] = "Send"; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[2] = "Dirty"; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].line[3] = "Count"; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].format = "%d"; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].display_value = &rem_dirty_count; |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SEND_DIRTY_COUNT); |
| netperf_output_source[REMOTE_SEND_DIRTY_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SEND_DIRTY_COUNT); |
| |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].output_name = REMOTE_RECV_DIRTY_COUNT; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[2] = "Dirty"; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].line[3] = "Count"; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].format = "%d"; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].display_value = &rem_dirty_count; |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_DIRTY_COUNT); |
| netperf_output_source[REMOTE_RECV_DIRTY_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_DIRTY_COUNT); |
| |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].output_name = REMOTE_RECV_CLEAN_COUNT; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[1] = "Recv"; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[2] = "Clean"; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].line[3] = "Count"; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].format = "%d"; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].display_value = &rem_clean_count; |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_RECV_CLEAN_COUNT); |
| netperf_output_source[REMOTE_RECV_CLEAN_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_RECV_CLEAN_COUNT); |
| |
| netperf_output_source[REMOTE_CPU_UTIL].output_name = REMOTE_CPU_UTIL; |
| netperf_output_source[REMOTE_CPU_UTIL].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_UTIL].line[1] = "CPU"; |
| netperf_output_source[REMOTE_CPU_UTIL].line[2] = "Util"; |
| netperf_output_source[REMOTE_CPU_UTIL].line[3] = "%"; |
| netperf_output_source[REMOTE_CPU_UTIL].format = "%.2f"; |
| netperf_output_source[REMOTE_CPU_UTIL].display_value = &remote_cpu_utilization_double; |
| netperf_output_source[REMOTE_CPU_UTIL].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_UTIL); |
| netperf_output_source[REMOTE_CPU_UTIL].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_UTIL); |
| |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].output_name = REMOTE_CPU_PEAK_UTIL; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[1] = "Peak"; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[2] = "Per CPU"; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].line[3] = "Util %"; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].format = "%.2f"; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].display_value = &lib_remote_peak_cpu_util; |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_PEAK_UTIL); |
| netperf_output_source[REMOTE_CPU_PEAK_UTIL].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_PEAK_UTIL); |
| |
| netperf_output_source[REMOTE_CPU_PEAK_ID].output_name = REMOTE_CPU_PEAK_ID; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].line[1] = "Peak"; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].line[2] = "Per CPU"; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].line[3] = "ID"; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].format = "%d"; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].display_value = &lib_remote_peak_cpu_id; |
| netperf_output_source[REMOTE_CPU_PEAK_ID].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_PEAK_ID); |
| netperf_output_source[REMOTE_CPU_PEAK_ID].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_PEAK_ID); |
| |
| netperf_output_source[REMOTE_CPU_BIND].output_name = REMOTE_CPU_BIND; |
| netperf_output_source[REMOTE_CPU_BIND].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_BIND].line[1] = "CPU"; |
| netperf_output_source[REMOTE_CPU_BIND].line[2] = "Bind"; |
| netperf_output_source[REMOTE_CPU_BIND].line[3] = ""; |
| netperf_output_source[REMOTE_CPU_BIND].format = "%d"; |
| netperf_output_source[REMOTE_CPU_BIND].display_value = &remote_proc_affinity; |
| netperf_output_source[REMOTE_CPU_BIND].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_BIND); |
| netperf_output_source[REMOTE_CPU_BIND].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_BIND); |
| |
| netperf_output_source[REMOTE_SD].output_name = REMOTE_SD; |
| netperf_output_source[REMOTE_SD].line[0] = "Remote"; |
| netperf_output_source[REMOTE_SD].line[1] = "Service"; |
| netperf_output_source[REMOTE_SD].line[2] = "Demand"; |
| netperf_output_source[REMOTE_SD].line[3] = ""; |
| netperf_output_source[REMOTE_SD].format = "%.3f"; |
| netperf_output_source[REMOTE_SD].display_value = &remote_service_demand_double; |
| netperf_output_source[REMOTE_SD].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_SD); |
| netperf_output_source[REMOTE_SD].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_SD); |
| |
| netperf_output_source[REMOTE_CPU_METHOD].output_name = REMOTE_CPU_METHOD; |
| netperf_output_source[REMOTE_CPU_METHOD].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_METHOD].line[1] = "CPU"; |
| netperf_output_source[REMOTE_CPU_METHOD].line[2] = "Util"; |
| netperf_output_source[REMOTE_CPU_METHOD].line[3] = "Method"; |
| netperf_output_source[REMOTE_CPU_METHOD].format = "%c"; |
| netperf_output_source[REMOTE_CPU_METHOD].display_value = &remote_cpu_method; |
| netperf_output_source[REMOTE_CPU_METHOD].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_METHOD); |
| netperf_output_source[REMOTE_CPU_METHOD].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_METHOD); |
| |
| netperf_output_source[REMOTE_CPU_COUNT].output_name = REMOTE_CPU_COUNT; |
| netperf_output_source[REMOTE_CPU_COUNT].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CPU_COUNT].line[1] = "CPU"; |
| netperf_output_source[REMOTE_CPU_COUNT].line[2] = "Count"; |
| netperf_output_source[REMOTE_CPU_COUNT].format = "%d"; |
| netperf_output_source[REMOTE_CPU_COUNT].display_value = &lib_num_rem_cpus; |
| netperf_output_source[REMOTE_CPU_COUNT].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CPU_COUNT); |
| netperf_output_source[REMOTE_CPU_COUNT].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CPU_COUNT); |
| |
| netperf_output_source[REMOTE_NODELAY].output_name = REMOTE_NODELAY; |
| netperf_output_source[REMOTE_NODELAY].line[0] = "Remote"; |
| netperf_output_source[REMOTE_NODELAY].line[1] = "NODELAY"; |
| netperf_output_source[REMOTE_NODELAY].line[2] = ""; |
| netperf_output_source[REMOTE_NODELAY].line[3] = ""; |
| netperf_output_source[REMOTE_NODELAY].format = "%d"; |
| netperf_output_source[REMOTE_NODELAY].display_value = &rem_nodelay; |
| netperf_output_source[REMOTE_NODELAY].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_NODELAY); |
| netperf_output_source[REMOTE_NODELAY].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_NODELAY); |
| |
| netperf_output_source[REMOTE_CORK].output_name = REMOTE_CORK; |
| netperf_output_source[REMOTE_CORK].line[0] = "Remote"; |
| netperf_output_source[REMOTE_CORK].line[1] = "Cork"; |
| netperf_output_source[REMOTE_CORK].line[2] = ""; |
| netperf_output_source[REMOTE_CORK].line[3] = ""; |
| netperf_output_source[REMOTE_CORK].format = "%d"; |
| netperf_output_source[REMOTE_CORK].display_value = &rem_tcpcork; |
| netperf_output_source[REMOTE_CORK].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_CORK); |
| netperf_output_source[REMOTE_CORK].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_CORK); |
| |
| netperf_output_source[LOCAL_DRIVER_NAME].output_name = LOCAL_DRIVER_NAME; |
| netperf_output_source[LOCAL_DRIVER_NAME].line[0] = "Local"; |
| netperf_output_source[LOCAL_DRIVER_NAME].line[1] = "Driver"; |
| netperf_output_source[LOCAL_DRIVER_NAME].line[2] = "Name"; |
| netperf_output_source[LOCAL_DRIVER_NAME].line[3] = ""; |
| netperf_output_source[LOCAL_DRIVER_NAME].format = "%s"; |
| netperf_output_source[LOCAL_DRIVER_NAME].display_value = local_driver_name; |
| netperf_output_source[LOCAL_DRIVER_NAME].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_DRIVER_NAME); |
| netperf_output_source[LOCAL_DRIVER_NAME].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_DRIVER_NAME); |
| |
| netperf_output_source[LOCAL_DRIVER_VERSION].output_name = LOCAL_DRIVER_VERSION; |
| netperf_output_source[LOCAL_DRIVER_VERSION].line[0] = "Local"; |
| netperf_output_source[LOCAL_DRIVER_VERSION].line[1] = "Driver"; |
| netperf_output_source[LOCAL_DRIVER_VERSION].line[2] = "Version"; |
| netperf_output_source[LOCAL_DRIVER_VERSION].line[3] = ""; |
| netperf_output_source[LOCAL_DRIVER_VERSION].format = "%s"; |
| netperf_output_source[LOCAL_DRIVER_VERSION].display_value = local_driver_version; |
| netperf_output_source[LOCAL_DRIVER_VERSION].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_DRIVER_VERSION); |
| netperf_output_source[LOCAL_DRIVER_VERSION].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_DRIVER_VERSION); |
| |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].output_name = LOCAL_DRIVER_FIRMWARE; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[0] = "Local"; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[1] = "Driver"; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[2] = "Firmware"; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].line[3] = ""; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].format = "%s"; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].display_value = local_driver_firmware; |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_DRIVER_FIRMWARE); |
| netperf_output_source[LOCAL_DRIVER_FIRMWARE].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_DRIVER_FIRMWARE); |
| |
| netperf_output_source[LOCAL_DRIVER_BUS].output_name = LOCAL_DRIVER_BUS; |
| netperf_output_source[LOCAL_DRIVER_BUS].line[0] = "Local"; |
| netperf_output_source[LOCAL_DRIVER_BUS].line[1] = "Driver"; |
| netperf_output_source[LOCAL_DRIVER_BUS].line[2] = "Bus"; |
| netperf_output_source[LOCAL_DRIVER_BUS].line[3] = ""; |
| netperf_output_source[LOCAL_DRIVER_BUS].format = "%s"; |
| netperf_output_source[LOCAL_DRIVER_BUS].display_value = local_driver_bus; |
| netperf_output_source[LOCAL_DRIVER_BUS].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_DRIVER_BUS); |
| netperf_output_source[LOCAL_DRIVER_BUS].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_DRIVER_BUS); |
| |
| netperf_output_source[REMOTE_DRIVER_NAME].output_name = REMOTE_DRIVER_NAME; |
| netperf_output_source[REMOTE_DRIVER_NAME].line[0] = "Remote"; |
| netperf_output_source[REMOTE_DRIVER_NAME].line[1] = "Driver"; |
| netperf_output_source[REMOTE_DRIVER_NAME].line[2] = "Name"; |
| netperf_output_source[REMOTE_DRIVER_NAME].line[3] = ""; |
| netperf_output_source[REMOTE_DRIVER_NAME].format = "%s"; |
| netperf_output_source[REMOTE_DRIVER_NAME].display_value = remote_driver_name; |
| netperf_output_source[REMOTE_DRIVER_NAME].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_DRIVER_NAME); |
| netperf_output_source[REMOTE_DRIVER_NAME].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_DRIVER_NAME); |
| |
| netperf_output_source[REMOTE_DRIVER_VERSION].output_name = REMOTE_DRIVER_VERSION; |
| netperf_output_source[REMOTE_DRIVER_VERSION].line[0] = "Remote"; |
| netperf_output_source[REMOTE_DRIVER_VERSION].line[1] = "Driver"; |
| netperf_output_source[REMOTE_DRIVER_VERSION].line[2] = "Version"; |
| netperf_output_source[REMOTE_DRIVER_VERSION].line[3] = ""; |
| netperf_output_source[REMOTE_DRIVER_VERSION].format = "%s"; |
| netperf_output_source[REMOTE_DRIVER_VERSION].display_value = remote_driver_version; |
| netperf_output_source[REMOTE_DRIVER_VERSION].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_DRIVER_VERSION); |
| netperf_output_source[REMOTE_DRIVER_VERSION].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_DRIVER_VERSION); |
| |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].output_name = REMOTE_DRIVER_FIRMWARE; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[0] = "Remote"; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[1] = "Driver"; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[2] = "Firmware"; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].line[3] = ""; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].format = "%s"; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].display_value = remote_driver_firmware; |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_DRIVER_FIRMWARE); |
| netperf_output_source[REMOTE_DRIVER_FIRMWARE].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_DRIVER_FIRMWARE); |
| |
| netperf_output_source[REMOTE_DRIVER_BUS].output_name = REMOTE_DRIVER_BUS; |
| netperf_output_source[REMOTE_DRIVER_BUS].line[0] = "Remote"; |
| netperf_output_source[REMOTE_DRIVER_BUS].line[1] = "Driver"; |
| netperf_output_source[REMOTE_DRIVER_BUS].line[2] = "Bus"; |
| netperf_output_source[REMOTE_DRIVER_BUS].line[3] = ""; |
| netperf_output_source[REMOTE_DRIVER_BUS].format = "%s"; |
| netperf_output_source[REMOTE_DRIVER_BUS].display_value = remote_driver_bus; |
| netperf_output_source[REMOTE_DRIVER_BUS].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_DRIVER_BUS); |
| netperf_output_source[REMOTE_DRIVER_BUS].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_DRIVER_BUS); |
| |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].output_name = LOCAL_INTERFACE_SUBDEVICE; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[0] = "Local"; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[1] = "Interface"; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[2] = "Subdevice"; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].line[3] = ""; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].format = "0x%.4x"; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].display_value = &local_interface_subdevice; |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_INTERFACE_SUBDEVICE); |
| netperf_output_source[LOCAL_INTERFACE_SUBDEVICE].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_INTERFACE_SUBDEVICE); |
| |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].output_name = LOCAL_INTERFACE_DEVICE; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].line[0] = "Local"; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].line[1] = "Interface"; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].line[2] = "Device"; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].line[3] = ""; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].format = "0x%.4x"; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].display_value = &local_interface_device; |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_INTERFACE_DEVICE); |
| netperf_output_source[LOCAL_INTERFACE_DEVICE].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_INTERFACE_DEVICE); |
| |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].output_name = LOCAL_INTERFACE_SUBVENDOR; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[0] = "Local"; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[1] = "Interface"; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[2] = "Subvendor"; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].line[3] = ""; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].format = "0x%.4x"; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].display_value = &local_interface_subvendor; |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_INTERFACE_SUBVENDOR); |
| netperf_output_source[LOCAL_INTERFACE_SUBVENDOR].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_INTERFACE_SUBVENDOR); |
| |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].output_name = LOCAL_INTERFACE_VENDOR; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].line[0] = "Local"; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].line[1] = "Interface"; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].line[2] = "Vendor"; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].line[3] = ""; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].format = "0x%.4x"; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].display_value = &local_interface_vendor; |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].max_line_len = |
| NETPERF_LINE_MAX(LOCAL_INTERFACE_VENDOR); |
| netperf_output_source[LOCAL_INTERFACE_VENDOR].tot_line_len = |
| NETPERF_LINE_TOT(LOCAL_INTERFACE_VENDOR); |
| |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].output_name = REMOTE_INTERFACE_SUBDEVICE; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[0] = "Remote"; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[1] = "Interface"; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[2] = "Subdevice"; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].line[3] = ""; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].format = "0x%.4x"; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].display_value = &remote_interface_subdevice; |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_INTERFACE_SUBDEVICE); |
| netperf_output_source[REMOTE_INTERFACE_SUBDEVICE].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_INTERFACE_SUBDEVICE); |
| |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].output_name = REMOTE_INTERFACE_DEVICE; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].line[0] = "Remote"; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].line[1] = "Interface"; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].line[2] = "Device"; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].line[3] = ""; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].format = "0x%.4x"; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].display_value = &remote_interface_device; |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_INTERFACE_DEVICE); |
| netperf_output_source[REMOTE_INTERFACE_DEVICE].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_INTERFACE_DEVICE); |
| |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].output_name = REMOTE_INTERFACE_SUBVENDOR; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[0] = "Remote"; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[1] = "Interface"; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[2] = "Subvendor"; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].line[3] = ""; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].format = "0x%.4x"; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].display_value = &remote_interface_subvendor; |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_INTERFACE_SUBVENDOR); |
| netperf_output_source[REMOTE_INTERFACE_SUBVENDOR].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_INTERFACE_SUBVENDOR); |
| |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].output_name = REMOTE_INTERFACE_VENDOR; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].line[0] = "Remote"; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].line[1] = "Interface"; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].line[2] = "Vendor"; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].line[3] = ""; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].format = "0x%.4x"; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].display_value = &remote_interface_vendor; |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].max_line_len = |
| NETPERF_LINE_MAX(REMOTE_INTERFACE_VENDOR); |
| netperf_output_source[REMOTE_INTERFACE_VENDOR].tot_line_len = |
| NETPERF_LINE_TOT(REMOTE_INTERFACE_VENDOR); |
| |
| netperf_output_source[LOCAL_INTERFACE_NAME].output_name = LOCAL_INTERFACE_NAME; |
| netperf_output_source[LOCAL_INTERFACE_NAME].line[0] = "Local"; |
| netperf_output_source[LOCAL_INTERFACE_NAME].line[
|
