1char netlib_id[]="\ 2@(#)netlib.c (c) Copyright 1993-2007 Hewlett-Packard Company. Version 2.4.3"; 3 4 5/****************************************************************/ 6/* */ 7/* netlib.c */ 8/* */ 9/* the common utility routines available to all... */ 10/* */ 11/* establish_control() establish the control socket */ 12/* calibrate_local_cpu() do local cpu calibration */ 13/* calibrate_remote_cpu() do remote cpu calibration */ 14/* send_request() send a request to the remote */ 15/* recv_response() receive a response from remote */ 16/* send_response() send a response to the remote */ 17/* recv_request() recv a request from the remote */ 18/* dump_request() dump request contents */ 19/* dump_response() dump response contents */ 20/* cpu_start() start measuring cpu */ 21/* cpu_stop() stop measuring cpu */ 22/* calc_cpu_util() calculate the cpu utilization */ 23/* calc_service_demand() calculate the service demand */ 24/* calc_thruput() calulate the tput in units */ 25/* calibrate() really calibrate local cpu */ 26/* identify_local() print local host information */ 27/* identify_remote() print remote host information */ 28/* format_number() format the number (KB, MB,etc) */ 29/* format_units() return the format in english */ 30/* msec_sleep() sleep for some msecs */ 31/* start_timer() start a timer */ 32/* */ 33/* the routines you get when WANT_DLPI is defined... */ 34/* */ 35/* dl_open() open a file descriptor and */ 36/* attach to the card */ 37/* dl_mtu() find the MTU of the card */ 38/* dl_bind() bind the sap do the card */ 39/* dl_connect() sender's have of connect */ 40/* dl_accpet() receiver's half of connect */ 41/* dl_set_window() set the window size */ 42/* dl_stats() retrieve statistics */ 43/* dl_send_disc() initiate disconnect (sender) */ 44/* dl_recv_disc() accept disconnect (receiver) */ 45/****************************************************************/ 46 47/****************************************************************/ 48/* */ 49/* Global include files */ 50/* */ 51/****************************************************************/ 52 53#ifdef HAVE_CONFIG_H 54#include "config.h" 55#endif 56 57 /* It would seem that most of the includes being done here from */ 58 /* "sys/" actually have higher-level wrappers at just /usr/include. */ 59 /* This is based on a spot-check of a couple systems at my disposal. */ 60 /* If you have trouble compiling you may want to add "sys/" raj 10/95 */ 61#include <limits.h> 62#include <signal.h> 63#ifdef MPE 64# define NSIG _NSIG 65#endif /* MPE */ 66#include <sys/types.h> 67#include <fcntl.h> 68#include <stdio.h> 69#include <stdlib.h> 70#include <math.h> 71#include <string.h> 72#include <assert.h> 73#ifdef HAVE_ENDIAN_H 74#include <endian.h> 75#endif 76 77 78#ifndef WIN32 79 /* at some point, I would like to get rid of all these "sys/" */ 80 /* includes where appropriate. if you have a system that requires */ 81 /* them, speak now, or your system may not comile later revisions of */ 82 /* netperf. raj 1/96 */ 83#include <unistd.h> 84#include <sys/stat.h> 85#include <sys/times.h> 86#ifndef MPE 87#include <time.h> 88#include <sys/time.h> 89#endif /* MPE */ 90#include <sys/socket.h> 91#include <netinet/in.h> 92#include <arpa/inet.h> 93#include <netdb.h> 94#include <errno.h> 95#include <sys/utsname.h> 96#if !defined(MPE) && !defined(__VMS) 97#include <sys/param.h> 98#endif /* MPE */ 99 100#else /* WIN32 */ 101 102#include <process.h> 103#include <time.h> 104#include <winsock2.h> 105#define netperf_socklen_t socklen_t 106#include <windows.h> 107 108/* the only time someone should need to define DONT_IPV6 in the 109 "sources" file is if they are trying to compile on Windows 2000 or 110 NT4 and I suspect this may not be their only problem :) */ 111#ifndef DONT_IPV6 112#include <ws2tcpip.h> 113#endif 114 115#include <windows.h> 116 117#define SIGALRM (14) 118#define sleep(x) Sleep((x)*1000) 119 120#endif /* WIN32 */ 121 122#ifdef _AIX 123#include <sys/select.h> 124#include <sys/sched.h> 125#include <sys/pri.h> 126#define PRIORITY PRI_LOW 127#else/* _AIX */ 128#ifdef __sgi 129#include <sys/prctl.h> 130#include <sys/schedctl.h> 131#define PRIORITY NDPLOMIN 132#endif /* __sgi */ 133#endif /* _AIX */ 134 135#ifdef WANT_DLPI 136#include <sys/stream.h> 137#include <sys/stropts.h> 138#include <sys/poll.h> 139#ifdef __osf__ 140#include <sys/dlpihdr.h> 141#else /* __osf__ */ 142#include <sys/dlpi.h> 143#ifdef __hpux 144#include <sys/dlpi_ext.h> 145#endif /* __hpux */ 146#endif /* __osf__ */ 147#endif /* WANT_DLPI */ 148 149#ifdef HAVE_MPCTL 150#include <sys/mpctl.h> 151#endif 152 153#if !defined(HAVE_GETADDRINFO) || !defined(HAVE_GETNAMEINFO) 154# include "missing/getaddrinfo.h" 155#endif 156 157 158#ifdef WANT_HISTOGRAM 159#include "hist.h" 160#endif /* WANT_HISTOGRAM */ 161/****************************************************************/ 162/* */ 163/* Local Include Files */ 164/* */ 165/****************************************************************/ 166#define NETLIB 167#include "netlib.h" 168#include "netsh.h" 169#include "netcpu.h" 170 171/****************************************************************/ 172/* */ 173/* Global constants, macros and variables */ 174/* */ 175/****************************************************************/ 176 177#if defined(WIN32) || defined(__VMS) 178struct timezone { 179 int dummy ; 180 } ; 181#ifndef __VMS 182SOCKET win_kludge_socket = INVALID_SOCKET; 183SOCKET win_kludge_socket2 = INVALID_SOCKET; 184#endif /* __VMS */ 185#endif /* WIN32 || __VMS */ 186 187#ifndef LONG_LONG_MAX 188#define LONG_LONG_MAX 9223372036854775807LL 189#endif /* LONG_LONG_MAX */ 190 191 /* older versions of netperf knew about the HP kernel IDLE counter. */ 192 /* this is now obsolete - in favor of either pstat(), times, or a */ 193 /* process-level looper process. we also now require support for the */ 194 /* "long" integer type. raj 4/95. */ 195 196int 197 lib_num_loc_cpus, /* the number of cpus in the system */ 198 lib_num_rem_cpus; /* how many we think are in the remote */ 199 200#define PAGES_PER_CHILD 2 201 202int lib_use_idle; 203int cpu_method; 204 205struct timeval time1, time2; 206struct timezone tz; 207float lib_elapsed, 208 lib_local_maxrate, 209 lib_remote_maxrate, 210 lib_local_cpu_util, 211 lib_remote_cpu_util; 212 213float lib_local_per_cpu_util[MAXCPUS]; 214int lib_cpu_map[MAXCPUS]; 215 216int *request_array; 217int *response_array; 218 219/* INVALID_SOCKET == INVALID_HANDLE_VALUE == (unsigned int)(~0) == -1 */ 220SOCKET netlib_control = INVALID_SOCKET; 221SOCKET server_sock = INVALID_SOCKET; 222 223/* global variables to hold the value for processor affinity */ 224int local_proc_affinity,remote_proc_affinity = -1; 225 226/* these are to allow netperf to be run easily through those evil, 227 end-to-end breaking things known as firewalls */ 228char local_data_port[10]; 229char remote_data_port[10]; 230 231char *local_data_address=NULL; 232char *remote_data_address=NULL; 233 234int local_data_family=AF_UNSPEC; 235int remote_data_family=AF_UNSPEC; 236 237 /* in the past, I was overlaying a structure on an array of ints. now */ 238 /* I am going to have a "real" structure, and point an array of ints */ 239 /* at it. the real structure will be forced to the same alignment as */ 240 /* the type "double." this change will mean that pre-2.1 netperfs */ 241 /* cannot be mixed with 2.1 and later. raj 11/95 */ 242 243union netperf_request_struct netperf_request; 244union netperf_response_struct netperf_response; 245 246FILE *where; 247 248char libfmt = '?'; 249 250#ifdef WANT_DLPI 251/* some stuff for DLPI control messages */ 252#define DLPI_DATA_SIZE 2048 253 254unsigned long control_data[DLPI_DATA_SIZE]; 255struct strbuf control_message = {DLPI_DATA_SIZE, 0, (char *)control_data}; 256 257#endif /* WANT_DLPI */ 258 259#ifdef WIN32 260HANDLE hAlarm = INVALID_HANDLE_VALUE; 261#endif 262 263int times_up; 264 265#ifdef WIN32 266 /* we use a getopt implementation from net.sources */ 267/* 268 * get option letter from argument vector 269 */ 270int 271 opterr = 1, /* should error messages be printed? */ 272 optind = 1, /* index into parent argv vector */ 273 optopt; /* character checked for validity */ 274char 275 *optarg; /* argument associated with option */ 276 277#define EMSG "" 278 279#endif /* WIN32 */ 280 281static int measuring_cpu; 282int 283netlib_get_page_size(void) { 284 285 /* not all systems seem to have the sysconf for page size. for 286 those which do not, we will assume that the page size is 8192 287 bytes. this should be more than enough to be sure that there is 288 no page or cache thrashing by looper processes on MP 289 systems. otherwise that's really just too bad - such systems 290 should define _SC_PAGE_SIZE - raj 4/95 */ 291 292#ifndef _SC_PAGE_SIZE 293#ifdef WIN32 294 295SYSTEM_INFO SystemInfo; 296 297 GetSystemInfo(&SystemInfo); 298 299 return SystemInfo.dwPageSize; 300#else 301 return(8192L); 302#endif /* WIN32 */ 303#else 304 return(sysconf(_SC_PAGE_SIZE)); 305#endif /* _SC_PAGE_SIZE */ 306 307} 308 309 310#ifdef WANT_INTERVALS 311static unsigned int usec_per_itvl; 312 313 314void 315stop_itimer() 316 317{ 318 319 struct itimerval new_interval; 320 struct itimerval old_interval; 321 322 new_interval.it_interval.tv_sec = 0; 323 new_interval.it_interval.tv_usec = 0; 324 new_interval.it_value.tv_sec = 0; 325 new_interval.it_value.tv_usec = 0; 326 if (setitimer(ITIMER_REAL,&new_interval,&old_interval) != 0) { 327 /* there was a problem arming the interval timer */ 328 perror("netperf: setitimer"); 329 exit(1); 330 } 331 return; 332} 333#endif /* WANT_INTERVALS */ 334 335 336 337#ifdef WIN32 338static void 339error(char *pch) 340{ 341 if (!opterr) { 342 return; /* without printing */ 343 } 344 fprintf(stderr, "%s: %s: %c\n", 345 (NULL != program) ? program : "getopt", pch, optopt); 346} 347 348int 349getopt(int argc, char **argv, char *ostr) 350{ 351 static char *place = EMSG; /* option letter processing */ 352 register char *oli; /* option letter list index */ 353 354 if (!*place) { 355 /* update scanning pointer */ 356 if (optind >= argc || *(place = argv[optind]) != '-' || !*++place) { 357 return EOF; 358 } 359 if (*place == '-') { 360 /* found "--" */ 361 ++optind; 362 place = EMSG ; /* Added by shiva for Netperf */ 363 return EOF; 364 } 365 } 366 367 /* option letter okay? */ 368 if ((optopt = (int)*place++) == (int)':' 369 || !(oli = strchr(ostr, optopt))) { 370 if (!*place) { 371 ++optind; 372 } 373 error("illegal option"); 374 return BADCH; 375 } 376 if (*++oli != ':') { 377 /* don't need argument */ 378 optarg = NULL; 379 if (!*place) 380 ++optind; 381 } else { 382 /* need an argument */ 383 if (*place) { 384 optarg = place; /* no white space */ 385 } else if (argc <= ++optind) { 386 /* no arg */ 387 place = EMSG; 388 error("option requires an argument"); 389 return BADCH; 390 } else { 391 optarg = argv[optind]; /* white space */ 392 } 393 place = EMSG; 394 ++optind; 395 } 396 return optopt; /* return option letter */ 397} 398#endif /* WIN32 */ 399 400/*---------------------------------------------------------------------------- 401 * WIN32 implementation of perror, does not deal very well with WSA errors 402 * The stdlib.h version of perror only deals with the ancient XENIX error codes. 403 * 404 * +*+SAF Why can't all WSA errors go through GetLastError? Most seem to... 405 *--------------------------------------------------------------------------*/ 406 407#ifdef WIN32 408void PrintWin32Error(FILE *stream, LPSTR text) 409{ 410 LPSTR szTemp; 411 DWORD dwResult; 412 DWORD dwError; 413 414 dwError = GetLastError(); 415 dwResult = FormatMessage( 416 FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM |FORMAT_MESSAGE_ARGUMENT_ARRAY, 417 NULL, 418 dwError, 419 LANG_NEUTRAL, 420 (LPTSTR)&szTemp, 421 0, 422 NULL ); 423 424 if (dwResult) 425 fprintf(stream, "%s: %s\n", text, szTemp); 426 else 427 fprintf(stream, "%s: error 0x%x\n", text, dwError); 428 fflush(stream); 429 430 if (szTemp) 431 LocalFree((HLOCAL)szTemp); 432} 433#endif /* WIN32 */ 434 435 436char * 437inet_ttos(int type) 438{ 439 switch (type) { 440 case SOCK_DGRAM: 441 return("SOCK_DGRAM"); 442 break; 443 case SOCK_STREAM: 444 return("SOCK_STREAM"); 445 break; 446 default: 447 return("SOCK_UNKNOWN"); 448 } 449} 450 451 452 453char unknown[32]; 454 455char * 456inet_ptos(int protocol) { 457 switch (protocol) { 458 case IPPROTO_TCP: 459 return("IPPROTO_TCP"); 460 break; 461 case IPPROTO_UDP: 462 return("IPPROTO_UDP"); 463 break; 464#if defined(IPPROTO_SCTP) 465 case IPPROTO_SCTP: 466 return("IPPROTO_SCTP"); 467 break; 468#endif 469 default: 470 snprintf(unknown,sizeof(unknown),"IPPROTO_UNKNOWN(%d)",protocol); 471 return(unknown); 472 } 473} 474 475/* one of these days, this should not be required */ 476#ifndef AF_INET_SDP 477#define AF_INET_SDP 27 478#define PF_INET_SDP AF_INET_SDP 479#endif 480 481char * 482inet_ftos(int family) 483{ 484 switch(family) { 485 case AF_INET: 486 return("AF_INET"); 487 break; 488#if defined(AF_INET6) 489 case AF_INET6: 490 return("AF_INET6"); 491 break; 492#endif 493#if defined(AF_INET_SDP) 494 case AF_INET_SDP: 495 return("AF_INET_SDP"); 496 break; 497#endif 498 default: 499 return("AF_UNSPEC"); 500 } 501} 502 503int 504inet_nton(int af, const void *src, char *dst, int cnt) 505 506{ 507 508 switch (af) { 509 case AF_INET: 510 /* magic constants again... :) */ 511 if (cnt >= 4) { 512 memcpy(dst,src,4); 513 return 4; 514 } 515 else { 516 Set_errno(ENOSPC); 517 return(-1); 518 } 519 break; 520#if defined(AF_INET6) 521 case AF_INET6: 522 if (cnt >= 16) { 523 memcpy(dst,src,16); 524 return(16); 525 } 526 else { 527 Set_errno(ENOSPC); 528 return(-1); 529 } 530 break; 531#endif 532 default: 533 Set_errno(EAFNOSUPPORT); 534 return(-1); 535 } 536} 537 538double 539ntohd(double net_double) 540 541{ 542 /* we rely on things being nicely packed */ 543 union { 544 double whole_thing; 545 unsigned int words[2]; 546 unsigned char bytes[8]; 547 } conv_rec; 548 549 unsigned char scratch; 550 int i; 551 552 /* on those systems where ntohl is a no-op, we want to return the */ 553 /* original value, unchanged */ 554 555 if (ntohl(1L) == 1L) { 556 return(net_double); 557 } 558 559 conv_rec.whole_thing = net_double; 560 561 /* we know that in the message passing routines that ntohl will have */ 562 /* been called on the 32 bit quantities. we need to put those back */ 563 /* the way they belong before we swap */ 564 conv_rec.words[0] = htonl(conv_rec.words[0]); 565 conv_rec.words[1] = htonl(conv_rec.words[1]); 566 567 /* now swap */ 568 for (i=0; i<= 3; i++) { 569 scratch = conv_rec.bytes[i]; 570 conv_rec.bytes[i] = conv_rec.bytes[7-i]; 571 conv_rec.bytes[7-i] = scratch; 572 } 573 574#if defined(__FLOAT_WORD_ORDER) && defined(__BYTE_ORDER) 575 if (__FLOAT_WORD_ORDER != __BYTE_ORDER) { 576 /* Fixup mixed endian floating point machines */ 577 unsigned int scratch = conv_rec.words[0]; 578 conv_rec.words[0] = conv_rec.words[1]; 579 conv_rec.words[1] = scratch; 580 } 581#endif 582 583 return(conv_rec.whole_thing); 584 585} 586 587double 588htond(double host_double) 589 590{ 591 /* we rely on things being nicely packed */ 592 union { 593 double whole_thing; 594 unsigned int words[2]; 595 unsigned char bytes[8]; 596 } conv_rec; 597 598 unsigned char scratch; 599 int i; 600 601 /* on those systems where ntohl is a no-op, we want to return the */ 602 /* original value, unchanged */ 603 604 if (ntohl(1L) == 1L) { 605 return(host_double); 606 } 607 608 conv_rec.whole_thing = host_double; 609 610 /* now swap */ 611 for (i=0; i<= 3; i++) { 612 scratch = conv_rec.bytes[i]; 613 conv_rec.bytes[i] = conv_rec.bytes[7-i]; 614 conv_rec.bytes[7-i] = scratch; 615 } 616 617#if defined(__FLOAT_WORD_ORDER) && defined(__BYTE_ORDER) 618 if (__FLOAT_WORD_ORDER != __BYTE_ORDER) { 619 /* Fixup mixed endian floating point machines */ 620 unsigned int scratch = conv_rec.words[0]; 621 conv_rec.words[0] = conv_rec.words[1]; 622 conv_rec.words[1] = scratch; 623 } 624#endif 625 626 /* we know that in the message passing routines htonl will */ 627 /* be called on the 32 bit quantities. we need to set things up so */ 628 /* that when this happens, the proper order will go out on the */ 629 /* network */ 630 conv_rec.words[0] = htonl(conv_rec.words[0]); 631 conv_rec.words[1] = htonl(conv_rec.words[1]); 632 633 return(conv_rec.whole_thing); 634 635} 636 637 638/* one of these days, this should be abstracted-out just like the CPU 639 util stuff. raj 2005-01-27 */ 640int 641get_num_cpus() 642 643{ 644 645 /* on HP-UX, even when we use the looper procs we need the pstat */ 646 /* call */ 647 648 int temp_cpus; 649 650#ifdef __hpux 651#include <sys/pstat.h> 652 653 struct pst_dynamic psd; 654 655 if (pstat_getdynamic((struct pst_dynamic *)&psd, 656 (size_t)sizeof(psd), (size_t)1, 0) != -1) { 657 temp_cpus = psd.psd_proc_cnt; 658 } 659 else { 660 temp_cpus = 1; 661 } 662 663#else 664 /* MW: <unistd.h> was included for non-Windows systems above. */ 665 /* Thus if _SC_NPROC_ONLN is defined, we should be able to use sysconf. */ 666#ifdef _SC_NPROCESSORS_ONLN 667 temp_cpus = sysconf(_SC_NPROCESSORS_ONLN); 668 669#ifdef USE_PERFSTAT 670 temp_cpus = perfstat_cpu(NULL,NULL, sizeof(perfstat_cpu_t), 0); 671#endif /* USE_PERFSTAT */ 672 673#else /* no _SC_NPROCESSORS_ONLN */ 674 675#ifdef WIN32 676 SYSTEM_INFO SystemInfo; 677 GetSystemInfo(&SystemInfo); 678 679 temp_cpus = SystemInfo.dwNumberOfProcessors; 680#else 681 /* we need to know some other ways to do this, or just fall-back on */ 682 /* a global command line option - raj 4/95 */ 683 temp_cpus = shell_num_cpus; 684#endif /* WIN32 */ 685#endif /* _SC_NPROCESSORS_ONLN */ 686#endif /* __hpux */ 687 688 if (temp_cpus > MAXCPUS) { 689 fprintf(where, 690 "Sorry, this system has more CPUs (%d) than I can handle (%d).\n", 691 temp_cpus, 692 MAXCPUS); 693 fprintf(where, 694 "Please alter MAXCPUS in netlib.h and recompile.\n"); 695 fflush(where); 696 exit(1); 697 } 698 699 return(temp_cpus); 700 701} 702 703#ifdef WIN32 704#ifdef __GNUC__ 705 #define S64_SUFFIX(x) x##LL 706#else 707 #define S64_SUFFIX(x) x##i64 708#endif 709 710/* 711 * Number of 100 nanosecond units from 1/1/1601 to 1/1/1970 712 */ 713#define EPOCH_BIAS S64_SUFFIX(116444736000000000) 714 715/* 716 * Union to facilitate converting from FILETIME to unsigned __int64 717 */ 718typedef union { 719 unsigned __int64 ft_scalar; 720 FILETIME ft_struct; 721} FT; 722 723void 724gettimeofday( struct timeval *tv , struct timezone *not_used ) 725{ 726 FT nt_time; 727 __int64 UnixTime; /* microseconds since 1/1/1970 */ 728 729 GetSystemTimeAsFileTime( &(nt_time.ft_struct) ); 730 731 UnixTime = ((nt_time.ft_scalar - EPOCH_BIAS) / S64_SUFFIX(10)); 732 tv->tv_sec = (long)(time_t)(UnixTime / S64_SUFFIX(1000000)); 733 tv->tv_usec = (unsigned long)(UnixTime % S64_SUFFIX(1000000)); 734} 735#endif /* WIN32 */ 736 737 738 739/************************************************************************/ 740/* */ 741/* signal catcher */ 742/* */ 743/************************************************************************/ 744 745void 746#if defined(__hpux) 747catcher(sig, code, scp) 748 int sig; 749 int code; 750 struct sigcontext *scp; 751#else 752catcher(int sig) 753#endif /* __hpux || __VMS */ 754{ 755 756#ifdef __hpux 757 if (debug > 2) { 758 fprintf(where,"caught signal %d ",sig); 759 if (scp) { 760 fprintf(where,"while in syscall %d\n", 761 scp->sc_syscall); 762 } 763 else { 764 fprintf(where,"null scp\n"); 765 } 766 fflush(where); 767 } 768#endif /* RAJ_DEBUG */ 769 770 switch(sig) { 771 772 case SIGINT: 773 fprintf(where,"netperf: caught SIGINT\n"); 774 fflush(where); 775 exit(1); 776 break; 777 case SIGALRM: 778 if (--test_len_ticks == 0) { 779 /* the test is over */ 780 if (times_up != 0) { 781 fprintf(where,"catcher: timer popped with times_up != 0\n"); 782 fflush(where); 783 } 784 times_up = 1; 785#if defined(WANT_INTERVALS) && !defined(WANT_SPIN) 786 stop_itimer(); 787#endif /* WANT_INTERVALS */ 788 break; 789 } 790 else { 791#ifdef WANT_INTERVALS 792#ifdef __hpux 793 /* the test is not over yet and we must have been using the */ 794 /* interval timer. if we were in SYS_SIGSUSPEND we want to */ 795 /* re-start the system call. Otherwise, we want to get out of */ 796 /* the sigsuspend call. I NEED TO KNOW HOW TO DO THIS FOR OTHER */ 797 /* OPERATING SYSTEMS. If you know how, please let me know. rick */ 798 /* jones <raj@cup.hp.com> */ 799 if (scp->sc_syscall != SYS_SIGSUSPEND) { 800 if (debug > 2) { 801 fprintf(where, 802 "catcher: Time to send burst > interval!\n"); 803 fflush(where); 804 } 805 scp->sc_syscall_action = SIG_RESTART; 806 } 807#endif /* __hpux */ 808#else /* WANT_INTERVALS */ 809 fprintf(where, 810 "catcher: interval timer running unexpectedly!\n"); 811 fflush(where); 812 times_up = 1; 813#endif /* WANT_INTERVALS */ 814 break; 815 } 816 } 817 return; 818} 819 820 821void 822install_signal_catchers() 823 824{ 825 /* just a simple little routine to catch a bunch of signals */ 826 827#ifndef WIN32 828 struct sigaction action; 829 int i; 830 831 fprintf(where,"installing catcher for all signals\n"); 832 fflush(where); 833 834 sigemptyset(&(action.sa_mask)); 835 action.sa_handler = catcher; 836 837#ifdef SA_INTERRUPT 838 action.sa_flags = SA_INTERRUPT; 839#else /* SA_INTERRUPT */ 840 action.sa_flags = 0; 841#endif /* SA_INTERRUPT */ 842 843 844 for (i = 1; i <= NSIG; i++) { 845 if (i != SIGALRM) { 846 if (sigaction(i,&action,NULL) != 0) { 847 fprintf(where, 848 "Could not install signal catcher for sig %d, errno %d\n", 849 i, 850 errno); 851 fflush(where); 852 853 } 854 } 855 } 856#else 857 return; 858#endif /* WIN32 */ 859} 860 861 862#ifdef WIN32 863#define SIGALRM (14) 864void 865emulate_alarm( int seconds ) 866{ 867 DWORD ErrorCode; 868 869 /* Wait on this event for parm seconds. */ 870 871 ErrorCode = WaitForSingleObject(hAlarm, seconds*1000); 872 if (ErrorCode == WAIT_FAILED) 873 { 874 perror("WaitForSingleObject failed"); 875 exit(1); 876 } 877 878 if (ErrorCode == WAIT_TIMEOUT) 879 { 880 /* WaitForSingleObject timed out; this means the timer 881 wasn't canceled. */ 882 883 times_up = 1; 884 885 /* We have yet to find a good way to fully emulate the effects */ 886 /* of signals and getting EINTR from system calls under */ 887 /* winsock, so what we do here is close the socket out from */ 888 /* under the other thread. It is rather kludgy, but should be */ 889 /* sufficient to get this puppy shipped. The concept can be */ 890 /* attributed/blamed :) on Robin raj 1/96 */ 891 892 if (win_kludge_socket != INVALID_SOCKET) { 893 closesocket(win_kludge_socket); 894 } 895 if (win_kludge_socket2 != INVALID_SOCKET) { 896 closesocket(win_kludge_socket2); 897 } 898 } 899} 900 901#endif /* WIN32 */ 902 903void 904start_timer(int time) 905{ 906 907#ifdef WIN32 908 /*+*+SAF What if StartTimer is called twice without the first timer */ 909 /*+*+SAF expiring? */ 910 911 DWORD thread_id ; 912 HANDLE tHandle; 913 914 if (hAlarm == (HANDLE) INVALID_HANDLE_VALUE) 915 { 916 /* Create the Alarm event object */ 917 hAlarm = CreateEvent( 918 (LPSECURITY_ATTRIBUTES) NULL, /* no security */ 919 FALSE, /* auto reset event */ 920 FALSE, /* init. state = reset */ 921 (void *)NULL); /* unnamed event object */ 922 if (hAlarm == (HANDLE) INVALID_HANDLE_VALUE) 923 { 924 perror("CreateEvent failure"); 925 exit(1); 926 } 927 } 928 else 929 { 930 ResetEvent(hAlarm); 931 } 932 933 934 tHandle = CreateThread(0, 935 0, 936 (LPTHREAD_START_ROUTINE)emulate_alarm, 937 (LPVOID)(ULONG_PTR)time, 938 0, 939 &thread_id ) ; 940 CloseHandle(tHandle); 941 942#else /* not WIN32 */ 943 944struct sigaction action; 945 946if (debug) { 947 fprintf(where,"About to start a timer for %d seconds.\n",time); 948 fflush(where); 949} 950 951 action.sa_handler = catcher; 952 sigemptyset(&(action.sa_mask)); 953 sigaddset(&(action.sa_mask),SIGALRM); 954 955#ifdef SA_INTERRUPT 956 /* on some systems (SunOS 4.blah), system calls are restarted. we do */ 957 /* not want that */ 958 action.sa_flags = SA_INTERRUPT; 959#else /* SA_INTERRUPT */ 960 action.sa_flags = 0; 961#endif /* SA_INTERRUPT */ 962 963 if (sigaction(SIGALRM, &action, NULL) < 0) { 964 fprintf(where,"start_timer: error installing alarm handler "); 965 fprintf(where,"errno %d\n",errno); 966 fflush(where); 967 exit(1); 968 } 969 970 /* this is the easy case - just set the timer for so many seconds */ 971 if (alarm(time) != 0) { 972 fprintf(where, 973 "error starting alarm timer, errno %d\n", 974 errno); 975 fflush(where); 976 } 977#endif /* WIN32 */ 978 979 test_len_ticks = 1; 980 981} 982 983 984 /* this routine will disable any running timer */ 985void 986stop_timer() 987{ 988#ifndef WIN32 989 alarm(0); 990#else 991 /* at some point we may need some win32 equivalent */ 992 if (hAlarm != (HANDLE) INVALID_HANDLE_VALUE) 993 { 994 SetEvent(hAlarm); 995 } 996#endif /* WIN32 */ 997 998} 999 1000 1001#ifdef WANT_INTERVALS 1002 /* this routine will enable the interval timer and set things up so */ 1003 /* that for a timed test the test will end at the proper time. it */ 1004 /* should detect the presence of POSIX.4 timer_* routines one of */ 1005 /* these days */ 1006void 1007start_itimer(unsigned int interval_len_msec ) 1008{ 1009 1010 unsigned int ticks_per_itvl; 1011 1012 struct itimerval new_interval; 1013 struct itimerval old_interval; 1014 1015 /* if -DWANT_INTERVALS was used, we will use the ticking of the itimer to */ 1016 /* tell us when the test is over. while the user will be specifying */ 1017 /* some number of milliseconds, we know that the interval timer is */ 1018 /* really in units of 1/HZ. so, to prevent the test from running */ 1019 /* "long" it would be necessary to keep this in mind when calculating */ 1020 /* the number of itimer events */ 1021 1022 ticks_per_itvl = ((interval_wate * sysconf(_SC_CLK_TCK) * 1000) / 1023 1000000); 1024 1025 if (ticks_per_itvl == 0) ticks_per_itvl = 1; 1026 1027 /* how many usecs in each interval? */ 1028 usec_per_itvl = ticks_per_itvl * (1000000 / sysconf(_SC_CLK_TCK)); 1029 1030 /* how many times will the timer pop before the test is over? */ 1031 if (test_time > 0) { 1032 /* this was a timed test */ 1033 test_len_ticks = (test_time * 1000000) / usec_per_itvl; 1034 } 1035 else { 1036 /* this was not a timed test, use MAXINT */ 1037 test_len_ticks = INT_MAX; 1038 } 1039 1040 if (debug) { 1041 fprintf(where,"setting the interval timer to %d sec %d usec ", 1042 usec_per_itvl / 1000000, 1043 usec_per_itvl % 1000000); 1044 fprintf(where,"test len %d ticks\n", 1045 test_len_ticks); 1046 fflush(where); 1047 } 1048 1049 /* if this was not a timed test, then we really aught to enable the */ 1050 /* signal catcher raj 2/95 */ 1051 1052 new_interval.it_interval.tv_sec = usec_per_itvl / 1000000; 1053 new_interval.it_interval.tv_usec = usec_per_itvl % 1000000; 1054 new_interval.it_value.tv_sec = usec_per_itvl / 1000000; 1055 new_interval.it_value.tv_usec = usec_per_itvl % 1000000; 1056 if (setitimer(ITIMER_REAL,&new_interval,&old_interval) != 0) { 1057 /* there was a problem arming the interval timer */ 1058 perror("netperf: setitimer"); 1059 exit(1); 1060 } 1061} 1062#endif /* WANT_INTERVALS */ 1063 1064void 1065netlib_init_cpu_map() { 1066 1067 int i; 1068#ifdef HAVE_MPCTL 1069 int num; 1070 i = 0; 1071 /* I go back and forth on whether this should be the system-wide set 1072 of calls, or if the processor set versions (sans the _SYS) should 1073 be used. at the moment I believe that the system-wide version 1074 should be used. raj 2006-04-03 */ 1075 num = mpctl(MPC_GETNUMSPUS_SYS,0,0); 1076 lib_cpu_map[i] = mpctl(MPC_GETFIRSTSPU_SYS,0,0); 1077 for (i = 1;((i < num) && (i < MAXCPUS)); i++) { 1078 lib_cpu_map[i] = mpctl(MPC_GETNEXTSPU_SYS,lib_cpu_map[i-1],0); 1079 } 1080 /* from here, we set them all to -1 because if we launch more 1081 loopers than actual CPUs, well, I'm not sure why :) */ 1082 for (; i < MAXCPUS; i++) { 1083 lib_cpu_map[i] = -1; 1084 } 1085 1086#else 1087 /* we assume that there is indeed a contiguous mapping */ 1088 for (i = 0; i < MAXCPUS; i++) { 1089 lib_cpu_map[i] = i; 1090 } 1091#endif 1092} 1093 1094 1095/****************************************************************/ 1096/* */ 1097/* netlib_init() */ 1098/* */ 1099/* initialize the performance library... */ 1100/* */ 1101/****************************************************************/ 1102 1103void 1104netlib_init() 1105{ 1106 int i; 1107 1108 where = stdout; 1109 1110 request_array = (int *)(&netperf_request); 1111 response_array = (int *)(&netperf_response); 1112 1113 for (i = 0; i < MAXCPUS; i++) { 1114 lib_local_per_cpu_util[i] = 0.0; 1115 } 1116 1117 /* on those systems where we know that CPU numbers may not start at 1118 zero and be contiguous, we provide a way to map from a 1119 contiguous, starting from 0 CPU id space to the actual CPU ids. 1120 at present this is only used for the netcpu_looper stuff because 1121 we ass-u-me that someone setting processor affinity from the 1122 netperf commandline will provide a "proper" CPU identifier. raj 1123 2006-04-03 */ 1124 1125 netlib_init_cpu_map(); 1126 1127 if (debug) { 1128 fprintf(where, 1129 "netlib_init: request_array at %p\n", 1130 request_array); 1131 fprintf(where, 1132 "netlib_init: response_array at %p\n", 1133 response_array); 1134 1135 fflush(where); 1136 } 1137 1138} 1139 1140 /* this routine will conver the string into an unsigned integer. it */ 1141 /* is used primarily for the command-line options taking a number */ 1142 /* (such as the socket size) which could be rather large. If someone */ 1143 /* enters 32M, then the number will be converted to 32 * 1024 * 1024. */ 1144 /* If they inter 32m, the number will be converted to 32 * 1000 * */ 1145 /* 1000 */ 1146unsigned int 1147convert(char *string) 1148 1149{ 1150 unsigned int base; 1151 base = atoi(string); 1152 if (strstr(string,"K")) { 1153 base *= 1024; 1154 } 1155 if (strstr(string,"M")) { 1156 base *= (1024 * 1024); 1157 } 1158 if (strstr(string,"G")) { 1159 base *= (1024 * 1024 * 1024); 1160 } 1161 if (strstr(string,"k")) { 1162 base *= (1000); 1163 } 1164 if (strstr(string,"m")) { 1165 base *= (1000 * 1000); 1166 } 1167 if (strstr(string,"g")) { 1168 base *= (1000 * 1000 * 1000); 1169 } 1170 return(base); 1171} 1172 1173/* this routine is like convert, but it is used for an interval time 1174 specification instead of stuff like socket buffer or send sizes. 1175 it converts everything to microseconds for internal use. if there 1176 is an 'm' at the end it assumes the user provided milliseconds, s 1177 will imply seconds, u will imply microseconds. in the future n 1178 will imply nanoseconds but for now it will be ignored. if there is 1179 no suffix or an unrecognized suffix, it will be assumed the user 1180 provided milliseconds, which was the long-time netperf default. one 1181 of these days, we should probably revisit that nanosecond business 1182 wrt the return value being just an int rather than a uint64_t or 1183 something. raj 2006-02-06 */ 1184 1185unsigned int 1186convert_timespec(char *string) { 1187 1188 unsigned int base; 1189 base = atoi(string); 1190 if (strstr(string,"m")) { 1191 base *= 1000; 1192 } 1193 else if (strstr(string,"u")) { 1194 base *= (1); 1195 } 1196 else if (strstr(string,"s")) { 1197 base *= (1000 * 1000); 1198 } 1199 else { 1200 base *= (1000); 1201 } 1202 return(base); 1203} 1204 1205 1206 /* this routine will allocate a circular list of buffers for either */ 1207 /* send or receive operations. each of these buffers will be aligned */ 1208 /* and offset as per the users request. the circumference of this */ 1209 /* ring will be controlled by the setting of send_width. the buffers */ 1210 /* will be filled with data from the file specified in fill_file. if */ 1211 /* fill_file is an empty string, the buffers will not be filled with */ 1212 /* any particular data */ 1213 1214struct ring_elt * 1215allocate_buffer_ring(int width, int buffer_size, int alignment, int offset) 1216{ 1217 1218 struct ring_elt *first_link = NULL; 1219 struct ring_elt *temp_link = NULL; 1220 struct ring_elt *prev_link; 1221 1222 int i; 1223 int malloc_size; 1224 int bytes_left; 1225 int bytes_read; 1226 int do_fill; 1227 1228 FILE *fill_source; 1229 char default_fill[] = "netperf"; 1230 int fill_cursor = 0; 1231 1232 malloc_size = buffer_size + alignment + offset; 1233 1234 /* did the user wish to have the buffers pre-filled with data from a */ 1235 /* particular source? */ 1236 if (strcmp(fill_file,"") == 0) { 1237 do_fill = 0; 1238 fill_source = NULL; 1239 } 1240 else { 1241 do_fill = 1; 1242 fill_source = (FILE *)fopen(fill_file,"r"); 1243 if (fill_source == (FILE *)NULL) { 1244 perror("Could not open requested fill file"); 1245 exit(1); 1246 } 1247 } 1248 1249 assert(width >= 1); 1250 1251 prev_link = NULL; 1252 for (i = 1; i <= width; i++) { 1253 /* get the ring element */ 1254 temp_link = (struct ring_elt *)malloc(sizeof(struct ring_elt)); 1255 if (temp_link == NULL) { 1256 printf("malloc(%u) failed!\n", sizeof(struct ring_elt)); 1257 exit(1); 1258 } 1259 /* remember the first one so we can close the ring at the end */ 1260 if (i == 1) { 1261 first_link = temp_link; 1262 } 1263 temp_link->buffer_base = (char *)malloc(malloc_size); 1264 if (temp_link == NULL) { 1265 printf("malloc(%d) failed!\n", malloc_size); 1266 exit(1); 1267 } 1268 1269#ifndef WIN32 1270 temp_link->buffer_ptr = (char *)(( (long)(temp_link->buffer_base) + 1271 (long)alignment - 1) & 1272 ~((long)alignment - 1)); 1273#else 1274 temp_link->buffer_ptr = (char *)(( (ULONG_PTR)(temp_link->buffer_base) + 1275 (ULONG_PTR)alignment - 1) & 1276 ~((ULONG_PTR)alignment - 1)); 1277#endif 1278 temp_link->buffer_ptr += offset; 1279 /* is where the buffer fill code goes. */ 1280 if (do_fill) { 1281 char *bufptr = temp_link->buffer_ptr; 1282 bytes_left = buffer_size; 1283 while (bytes_left) { 1284 if (((bytes_read = (int)fread(bufptr, 1285 1, 1286 bytes_left, 1287 fill_source)) == 0) && 1288 (feof(fill_source))){ 1289 rewind(fill_source); 1290 } 1291 bufptr += bytes_read; 1292 bytes_left -= bytes_read; 1293 } 1294 } 1295 else { 1296 /* use the default fill to ID our data traffic on the 1297 network. it ain't exactly pretty, but it should work */ 1298 int j; 1299 char *bufptr = temp_link->buffer_ptr; 1300 for (j = 0; j < buffer_size; j++) { 1301 bufptr[j] = default_fill[fill_cursor]; 1302 fill_cursor += 1; 1303 /* the Windows DDK compiler with an x86_64 target wants a cast 1304 here */ 1305 if (fill_cursor > (int)strlen(default_fill)) { 1306 fill_cursor = 0; 1307 } 1308 } 1309 1310 } 1311 temp_link->next = prev_link; 1312 prev_link = temp_link; 1313 } 1314 if (first_link) { /* SAF Prefast made me do it... */ 1315 first_link->next = temp_link; 1316 } 1317 1318 return(first_link); /* it's a circle, doesn't matter which we return */ 1319} 1320 1321/* this routine will dirty the first dirty_count bytes of the 1322 specified buffer and/or read clean_count bytes from the buffer. it 1323 will go N bytes at a time, the only question is how large should N 1324 be and if we should be going continguously, or based on some 1325 assumption of cache line size */ 1326 1327void 1328access_buffer(char *buffer_ptr,int length, int dirty_count, int clean_count) { 1329 1330 char *temp_buffer; 1331 char *limit; 1332 int i, dirty_totals; 1333 1334 temp_buffer = buffer_ptr; 1335 limit = temp_buffer + length; 1336 dirty_totals = 0; 1337 1338 for (i = 0; 1339 ((i < dirty_count) && (temp_buffer < limit)); 1340 i++) { 1341 *temp_buffer += (char)i; 1342 dirty_totals += *temp_buffer; 1343 temp_buffer++; 1344 } 1345 1346 for (i = 0; 1347 ((i < clean_count) && (temp_buffer < limit)); 1348 i++) { 1349 dirty_totals += *temp_buffer; 1350 temp_buffer++; 1351 } 1352 1353 if (debug > 100) { 1354 fprintf(where, 1355 "This was here to try to avoid dead-code elimination %d\n", 1356 dirty_totals); 1357 fflush(where); 1358 } 1359} 1360 1361 1362#ifdef HAVE_ICSC_EXS 1363 1364#include <sys/mman.h> 1365#include <sys/exs.h> 1366 1367 /* this routine will allocate a circular list of buffers for either */ 1368 /* send or receive operations. each of these buffers will be aligned */ 1369 /* and offset as per the users request. the circumference of this */ 1370 /* ring will be controlled by the setting of send_width. the buffers */ 1371 /* will be filled with data from the file specified in fill_file. if */ 1372 /* fill_file is an empty string, the buffers will not be filled with */ 1373 /* any particular data */ 1374 1375struct ring_elt * 1376allocate_exs_buffer_ring (int width, int buffer_size, int alignment, int offset, exs_mhandle_t *mhandlep) 1377{ 1378 1379 struct ring_elt *first_link; 1380 struct ring_elt *temp_link; 1381 struct ring_elt *prev_link; 1382 1383 int i; 1384 int malloc_size; 1385 int bytes_left; 1386 int bytes_read; 1387 int do_fill; 1388 1389 FILE *fill_source; 1390 1391 int mmap_size; 1392 char *mmap_buffer, *mmap_buffer_aligned; 1393 1394 malloc_size = buffer_size + alignment + offset; 1395 1396 /* did the user wish to have the buffers pre-filled with data from a */ 1397 /* particular source? */ 1398 if (strcmp (fill_file, "") == 0) { 1399 do_fill = 0; 1400 fill_source = NULL; 1401 } else { 1402 do_fill = 1; 1403 fill_source = (FILE *) fopen (fill_file, "r"); 1404 if (fill_source == (FILE *) NULL) { 1405 perror ("Could not open requested fill file"); 1406 exit (1); 1407 } 1408 } 1409 1410 assert (width >= 1); 1411 1412 if (debug) { 1413 fprintf (where, "allocate_exs_buffer_ring: " 1414 "width=%d buffer_size=%d alignment=%d offset=%d\n", 1415 width, buffer_size, alignment, offset); 1416 } 1417 1418 /* allocate shared memory */ 1419 mmap_size = width * malloc_size; 1420 mmap_buffer = (char *) mmap ((caddr_t)NULL, mmap_size+NBPG-1, 1421 PROT_READ|PROT_WRITE, 1422 MAP_SHARED|MAP_ANONYMOUS, -1, 0); 1423 if (mmap_buffer == NULL) { 1424 perror ("allocate_exs_buffer_ring: mmap failed"); 1425 exit (1); 1426 } 1427 mmap_buffer_aligned = (char *) ((uintptr_t)mmap_buffer & ~(NBPG-1)); 1428 if (debug) { 1429 fprintf (where, "allocate_exs_buffer_ring: " 1430 "mmap buffer size=%d address=0x%p aligned=0x%p\n", 1431 mmap_size, mmap_buffer, mmap_buffer_aligned); 1432 } 1433 1434 /* register shared memory */ 1435 *mhandlep = exs_mregister ((void *)mmap_buffer_aligned, (size_t)mmap_size, 0); 1436 if (*mhandlep == EXS_MHANDLE_INVALID) { 1437 perror ("allocate_exs_buffer_ring: exs_mregister failed"); 1438 exit (1); 1439 } 1440 if (debug) { 1441 fprintf (where, "allocate_exs_buffer_ring: mhandle=%d\n", 1442 *mhandlep); 1443 } 1444 1445 /* allocate ring elements */ 1446 first_link = (struct ring_elt *) malloc (width * sizeof (struct ring_elt)); 1447 if (first_link == NULL) { 1448 printf ("malloc(%d) failed!\n", width * sizeof (struct ring_elt)); 1449 exit (1); 1450 } 1451 1452 /* initialize buffer ring */ 1453 prev_link = first_link + width - 1; 1454 1455 for (i = 0, temp_link = first_link; i < width; i++, temp_link++) { 1456 1457 temp_link->buffer_base = (char *) mmap_buffer_aligned + (i*malloc_size); 1458#ifndef WIN32 1459 temp_link->buffer_ptr = (char *) 1460 (((long)temp_link->buffer_base + (long)alignment - 1) & 1461 ~((long)alignment - 1)); 1462#else 1463 temp_link->buffer_ptr = (char *) 1464 (((ULONG_PTR)temp_link->buffer_base + (ULONG_PTR)alignment - 1) & 1465 ~((ULONG_PTR)alignment - 1)); 1466#endif 1467 temp_link->buffer_ptr += offset; 1468 1469 if (debug) { 1470 fprintf (where, "allocate_exs_buffer_ring: " 1471 "buffer: index=%d base=0x%p ptr=0x%p\n", 1472 i, temp_link->buffer_base, temp_link->buffer_ptr); 1473 } 1474 1475 /* is where the buffer fill code goes. */ 1476 if (do_fill) { 1477 bytes_left = buffer_size; 1478 while (bytes_left) { 1479 if (((bytes_read = (int) fread (temp_link->buffer_ptr, 1480 1, 1481 bytes_left, 1482 fill_source)) == 0) && 1483 (feof (fill_source))) { 1484 rewind (fill_source); 1485 } 1486 bytes_left -= bytes_read; 1487 } 1488 } 1489 1490 /* do linking */ 1491 prev_link->next = temp_link; 1492 prev_link = temp_link; 1493 } 1494 1495 return (first_link); /* it's a circle, doesn't matter which we return */ 1496} 1497 1498#endif /* HAVE_ICSC_EXS */ 1499 1500 1501 1502#ifdef HAVE_SENDFILE 1503/* this routine will construct a ring of sendfile_ring_elt structs 1504 that the routine sendfile_tcp_stream() will use to get parameters 1505 to its calls to sendfile(). It will setup the ring to point at the 1506 file specified in the global -F option that is already used to 1507 pre-fill buffers in the send() case. 08/2000 1508 1509 if there is no file specified in a global -F option, we will create 1510 a tempoarary file and fill it with random data and use that 1511 instead. raj 2007-08-09 */ 1512 1513struct sendfile_ring_elt * 1514alloc_sendfile_buf_ring(int width, 1515 int buffer_size, 1516 int alignment, 1517 int offset) 1518 1519{ 1520 1521 struct sendfile_ring_elt *first_link = NULL; 1522 struct sendfile_ring_elt *temp_link = NULL; 1523 struct sendfile_ring_elt *prev_link; 1524 1525 int i; 1526 int fildes; 1527 struct stat statbuf; 1528 1529 /* if the user has not specified a file with the -F option, we will 1530 fail the test. otherwise, go ahead and try to open the 1531 file. 08/2000 */ 1532 if (strcmp(fill_file,"") == 0) { 1533 /* use an temp file for the fill file */ 1534 char *temp_file; 1535 int *temp_buffer; 1536 1537 /* make sure we have at least an ints worth, even if the user is 1538 using an insane buffer size for a sendfile test. we are 1539 ass-u-me-ing that malloc will return something at least aligned 1540 on an int boundary... */ 1541 temp_buffer = (int *) malloc(buffer_size + sizeof(int)); 1542 if (temp_buffer) { 1543 /* ok, we have the buffer we are going to write, lets get a 1544 temporary filename */ 1545 temp_file = tmpnam(NULL); 1546 if (NULL != temp_file) { 1547 fildes = open(temp_file,O_RDWR | O_EXCL | O_CREAT,0600); 1548 if (-1 != fildes) { 1549 int count; 1550 int *int_ptr; 1551 1552 /* initialize the random number generator */ 1553 srand(getpid()); 1554 1555 /* unlink the file so it goes poof when we 1556 exit. unless/until shown to be a problem we will 1557 blissfully ignore the return value. raj 2007-08-09 */ 1558 unlink(temp_file); 1559 1560 /* now fill-out the file with at least buffer_size * width bytes */ 1561 for (count = 0; count < width; count++) { 1562 /* fill the buffer with random data. it doesn't have to be 1563 really random, just "random enough" :) we do this here rather 1564 than up above because we want each write to the file to be 1565 different random data */ 1566 int_ptr = temp_buffer; 1567 for (i = 0; i <= buffer_size/sizeof(int); i++) { 1568 *int_ptr = rand(); 1569 int_ptr++; 1570 } 1571 if (write(fildes,temp_buffer,buffer_size+sizeof(int)) != 1572 buffer_size + sizeof(int)) { 1573 perror("allocate_sendfile_buf_ring: incomplete write"); 1574 exit(-1); 1575 } 1576 } 1577 } 1578 else { 1579 perror("allocate_sendfile_buf_ring: could not open tempfile"); 1580 exit(-1); 1581 } 1582 } 1583 else { 1584 perror("allocate_sendfile_buf_ring: could not allocate temp name"); 1585 exit(-1); 1586 } 1587 } 1588 else { 1589 perror("alloc_sendfile_buf_ring: could not allocate buffer for file"); 1590 exit(-1); 1591 } 1592 } 1593 else { 1594 /* the user pointed us at a file, so try it */ 1595 fildes = open(fill_file , O_RDONLY); 1596 if (fildes == -1){ 1597 perror("alloc_sendfile_buf_ring: Could not open requested file"); 1598 exit(1); 1599 } 1600 /* make sure there is enough file there to allow us to make a 1601 complete ring. that way we do not need additional logic in the 1602 ring setup to deal with wrap-around issues. we might want that 1603 someday, but not just now. 08/2000 */ 1604 if (stat(fill_file,&statbuf) != 0) { 1605 perror("alloc_sendfile_buf_ring: could not stat file"); 1606 exit(1); 1607 } 1608 if (statbuf.st_size < (width * buffer_size)) { 1609 /* the file is too short */ 1610 fprintf(stderr,"alloc_sendfile_buf_ring: specified file too small.\n"); 1611 fprintf(stderr,"file must be larger than send_width * send_size\n"); 1612 fflush(stderr); 1613 exit(1); 1614 } 1615 } 1616 1617 /* so, at this point we know that fildes is a descriptor which 1618 references a file of sufficient size for our nefarious 1619 porpoises. raj 2007-08-09 */ 1620 1621 prev_link = NULL; 1622 for (i = 1; i <= width; i++) { 1623 /* get the ring element. we should probably make sure the malloc() 1624 was successful, but for now we'll just let the code bomb 1625 mysteriously. 08/2000 */ 1626 1627 temp_link = (struct sendfile_ring_elt *) 1628 malloc(sizeof(struct sendfile_ring_elt)); 1629 if (temp_link == NULL) { 1630 printf("malloc(%u) failed!\n", sizeof(struct sendfile_ring_elt)); 1631 exit(1); 1632 } 1633 1634 /* remember the first one so we can close the ring at the end */ 1635 1636 if (i == 1) { 1637 first_link = temp_link; 1638 } 1639 1640 /* now fill-in the fields of the structure with the apropriate 1641 stuff. just how should we deal with alignment and offset I 1642 wonder? until something better comes-up, I think we will just 1643 ignore them. 08/2000 */ 1644 1645 temp_link->fildes = fildes; /* from which file do we send? */ 1646 temp_link->offset = offset; /* starting at which offset? */ 1647 offset += buffer_size; /* get ready for the next elt */ 1648 temp_link->length = buffer_size; /* how many bytes to send */ 1649 temp_link->hdtrl = NULL; /* no header or trailer */ 1650 temp_link->flags = 0; /* no flags */ 1651 1652 /* is where the buffer fill code went. */ 1653 1654 temp_link->next = prev_link; 1655 prev_link = temp_link; 1656 } 1657 /* close the ring */ 1658 first_link->next = temp_link; 1659 1660 return(first_link); /* it's a dummy ring */ 1661} 1662 1663#endif /* HAVE_SENDFILE */ 1664 1665 1666 /***********************************************************************/ 1667 /* */ 1668 /* dump_request() */ 1669 /* */ 1670 /* display the contents of the request array to the user. it will */ 1671 /* display the contents in decimal, hex, and ascii, with four bytes */ 1672 /* per line. */ 1673 /* */ 1674 /***********************************************************************/ 1675 1676void 1677dump_request() 1678{ 1679int counter = 0; 1680fprintf(where,"request contents:\n"); 1681for (counter = 0; counter < ((sizeof(netperf_request)/4)-3); counter += 4) { 1682 fprintf(where,"%d:\t%8x %8x %8x %8x \t|%4.4s| |%4.4s| |%4.4s| |%4.4s|\n", 1683 counter, 1684 request_array[counter], 1685 request_array[counter+1], 1686 request_array[counter+2], 1687 request_array[counter+3], 1688 (char *)&request_array[counter], 1689 (char *)&request_array[counter+1], 1690 (char *)&request_array[counter+2], 1691 (char *)&request_array[counter+3]); 1692} 1693fflush(where); 1694} 1695 1696 1697 /***********************************************************************/ 1698 /* */ 1699 /* dump_response() */ 1700 /* */ 1701 /* display the content of the response array to the user. it will */ 1702 /* display the contents in decimal, hex, and ascii, with four bytes */ 1703 /* per line. */ 1704 /* */ 1705 /***********************************************************************/ 1706 1707void 1708dump_response() 1709{ 1710int counter = 0; 1711 1712fprintf(where,"response contents\n"); 1713for (counter = 0; counter < ((sizeof(netperf_response)/4)-3); counter += 4) { 1714 fprintf(where,"%d:\t%8x %8x %8x %8x \t>%4.4s< >%4.4s< >%4.4s< >%4.4s<\n", 1715 counter, 1716 response_array[counter], 1717 response_array[counter+1], 1718 response_array[counter+2], 1719 response_array[counter+3], 1720 (char *)&response_array[counter], 1721 (char *)&response_array[counter+1], 1722 (char *)&response_array[counter+2], 1723 (char *)&response_array[counter+3]); 1724} 1725fflush(where); 1726} 1727 1728 /* 1729 1730 format_number() 1731 1732 return a pointer to a formatted string containing the value passed 1733 translated into the units specified. It assumes that the base units 1734 are bytes. If the format calls for bits, it will use SI units (10^) 1735 if the format calls for bytes, it will use CS units (2^)... This 1736 routine should look familiar to uses of the latest ttcp... 1737 1738 we would like to use "t" or "T" for transactions, but probably 1739 should leave those for terabits and terabytes respectively, so for 1740 transactions, we will use "x" which will, by default, do absolutely 1741 nothing to the result. why? so we don't have to special case code 1742 elsewhere such as in the TCP_RR-as-bidirectional test case. 1743 1744 */ 1745 1746 1747char * 1748format_number(double number) 1749{ 1750 static char fmtbuf[64]; 1751 1752 switch (libfmt) { 1753 case 'K': 1754 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f" , number / 1024.0); 1755 break; 1756 case 'M': 1757 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number / 1024.0 / 1024.0); 1758 break; 1759 case 'G': 1760 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number / 1024.0 / 1024.0 / 1024.0); 1761 break; 1762 case 'k': 1763 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number * 8 / 1000.0); 1764 break; 1765 case 'm': 1766 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number * 8 / 1000.0 / 1000.0); 1767 break; 1768 case 'g': 1769 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number * 8 / 1000.0 / 1000.0 / 1000.0); 1770 break; 1771 case 'x': 1772 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number); 1773 break; 1774 default: 1775 snprintf(fmtbuf, sizeof(fmtbuf), "%-7.2f", number / 1024.0); 1776 } 1777 1778 return fmtbuf; 1779} 1780 1781char 1782format_cpu_method(int method) 1783{ 1784 1785 char method_char; 1786 1787 switch (method) { 1788 case CPU_UNKNOWN: 1789 method_char = 'U'; 1790 break; 1791 case HP_IDLE_COUNTER: 1792 method_char = 'I'; 1793 break; 1794 case PSTAT: 1795 method_char = 'P'; 1796 break; 1797 case KSTAT: 1798 method_char = 'K'; 1799 break; 1800 case KSTAT_10: 1801 method_char = 'M'; 1802 break; 1803 case PERFSTAT: 1804 method_char = 'E'; 1805 break; 1806 case TIMES: /* historical only, completely unsuitable 1807 for netperf's purposes */ 1808 method_char = 'T'; 1809 break; 1810 case GETRUSAGE: /* historical only, completely unsuitable 1811 for netperf;s purposes */ 1812 method_char = 'R'; 1813 break; 1814 case LOOPER: 1815 method_char = 'L'; 1816 break; 1817 case NT_METHOD: 1818 method_char = 'N'; 1819 break; 1820 case PROC_STAT: 1821 method_char = 'S'; 1822 break; 1823 case SYSCTL: 1824 method_char = 'C'; 1825 break; 1826 case OSX: 1827 method_char = 'O'; 1828 break; 1829 default: 1830 method_char = '?'; 1831 } 1832 1833 return method_char; 1834 1835} 1836 1837char * 1838format_units() 1839{ 1840 static char unitbuf[64]; 1841 1842 switch (libfmt) { 1843 case 'K': 1844 strcpy(unitbuf, "KBytes"); 1845 break; 1846 case 'M': 1847 strcpy(unitbuf, "MBytes"); 1848 break; 1849 case 'G': 1850 strcpy(unitbuf, "GBytes"); 1851 break; 1852 case 'k': 1853 strcpy(unitbuf, "10^3bits"); 1854 break; 1855 case 'm': 1856 strcpy(unitbuf, "10^6bits"); 1857 break; 1858 case 'g': 1859 strcpy(unitbuf, "10^9bits"); 1860 break; 1861 case 'x': 1862 strcpy(unitbuf, "Trans"); 1863 break; 1864 1865 default: 1866 strcpy(unitbuf, "KBytes"); 1867 } 1868 1869 return unitbuf; 1870} 1871 1872 1873/****************************************************************/ 1874/* */ 1875/* shutdown_control() */ 1876/* */ 1877/* tear-down the control connection between me and the server. */ 1878/****************************************************************/ 1879 1880void 1881shutdown_control() 1882{ 1883 1884 char *buf = (char *)&netperf_response; 1885 int buflen = sizeof(netperf_response); 1886 1887 /* stuff for select, use fd_set for better compliance */ 1888 fd_set readfds; 1889 struct timeval timeout; 1890 1891 if (debug) { 1892 fprintf(where, 1893 "shutdown_control: shutdown of control connection requested.\n"); 1894 fflush(where); 1895 } 1896 1897 /* first, we say that we will be sending no more data on the */ 1898 /* connection */ 1899 if (shutdown(netlib_control,1) == SOCKET_ERROR) { 1900 Print_errno(where, 1901 "shutdown_control: error in shutdown"); 1902 fflush(where); 1903 exit(1); 1904 } 1905 1906 /* Now, we hang on a select waiting for the socket to become */ 1907 /* readable to receive the shutdown indication from the remote. this */ 1908 /* will be "just" like the recv_response() code */ 1909 1910 /* we only select once. it is assumed that if the response is split */ 1911 /* (which should not be happening, that we will receive the whole */ 1912 /* thing and not have a problem ;-) */ 1913 1914 FD_ZERO(&readfds); 1915 FD_SET(netlib_control,&readfds); 1916 timeout.tv_sec = 60; /* wait one minute then punt */ 1917 timeout.tv_usec = 0; 1918 1919 /* select had better return one, or there was either a problem or a */ 1920 /* timeout... */ 1921 if (select(FD_SETSIZE, 1922 &readfds, 1923 0, 1924 0, 1925 &timeout) != 1) { 1926 Print_errno(where, 1927 "shutdown_control: no response received"); 1928 fflush(where); 1929 exit(1); 1930 } 1931 1932 /* we now assume that the socket has come ready for reading */ 1933 recv(netlib_control, buf, buflen,0); 1934 1935} 1936 1937/* 1938 bind_to_specific_processor will bind the calling process to the 1939 processor in "processor" It has lots of ugly ifdefs to deal with 1940 all the different ways systems do processor affinity. this is a 1941 generalization of work initially done by stephen burger. raj 1942 2004/12/13 */ 1943 1944void 1945bind_to_specific_processor(int processor_affinity, int use_cpu_map) 1946{ 1947 1948 int mapped_affinity; 1949 1950 /* this is in place because the netcpu_looper processor affinity 1951 ass-u-me-s a contiguous CPU id space starting with 0. for the 1952 regular netperf/netserver affinity, we ass-u-me the user has used 1953 a suitable CPU id even when the space is not contiguous and 1954 starting from zero */ 1955 if (use_cpu_map) { 1956 mapped_affinity = lib_cpu_map[processor_affinity]; 1957 } 1958 else { 1959 mapped_affinity = processor_affinity; 1960 } 1961 1962#ifdef HAVE_MPCTL 1963 /* indeed, at some point it would be a good idea to check the return 1964 status and pass-along notification of error... raj 2004/12/13 */ 1965 mpctl(MPC_SETPROCESS_FORCE, mapped_affinity, getpid()); 1966#elif HAVE_PROCESSOR_BIND 1967#include <sys/types.h> 1968#include <sys/processor.h> 1969#include <sys/procset.h> 1970 processor_bind(P_PID,P_MYID,mapped_affinity,NULL); 1971#elif HAVE_BINDPROCESSOR 1972#include <sys/processor.h> 1973 /* this is the call on AIX. It takes a "what" of BINDPROCESS or 1974 BINDTHRAD, then "who" and finally "where" which is a CPU number 1975 or it seems PROCESSOR_CLASS_ANY there also seems to be a mycpu() 1976 call to return the current CPU assignment. this is all based on 1977 the sys/processor.h include file. from empirical testing, it 1978 would seem that the my_cpu() call returns the current CPU on 1979 which we are running rather than the CPU binding, so it's return 1980 value will not tell you if you are bound vs unbound. */ 1981 bindprocessor(BINDPROCESS,getpid(),(cpu_t)mapped_affinity); 1982#elif HAVE_SCHED_SETAFFINITY 1983#include <sched.h> 1984 /* in theory this should cover systems with more CPUs than bits in a 1985 long, without having to specify __USE_GNU. we "cheat" by taking 1986 defines from /usr/include/bits/sched.h, which we ass-u-me is 1987 included by <sched.h>. If they are not there we will just 1988 fall-back on what we had before, which is to use just the size of 1989 an unsigned long. raj 2006-09-14 */ 1990 1991#if defined(__CPU_SETSIZE) 1992#define NETPERF_CPU_SETSIZE __CPU_SETSIZE 1993#define NETPERF_CPU_SET(cpu, cpusetp) __CPU_SET(cpu, cpusetp) 1994#define NETPERF_CPU_ZERO(cpusetp) __CPU_ZERO (cpusetp) 1995 typedef cpu_set_t netperf_cpu_set_t; 1996#else 1997#define NETPERF_CPU_SETSIZE sizeof(unsigned long) 1998#define NETPERF_CPU_SET(cpu, cpusetp) *cpusetp = 1 << cpu 1999#define NETPERF_CPU_ZERO(cpusetp) *cpusetp = (unsigned long)0 2000 typedef unsigned long netperf_cpu_set_t; 2001#endif 2002 2003 netperf_cpu_set_t netperf_cpu_set; 2004 unsigned int len = sizeof(netperf_cpu_set); 2005 2006 if (mapped_affinity < 8*sizeof(netperf_cpu_set)) { 2007 NETPERF_CPU_ZERO(&netperf_cpu_set); 2008 NETPERF_CPU_SET(mapped_affinity,&netperf_cpu_set); 2009 2010 if (sched_setaffinity(getpid(), len, &netperf_cpu_set)) { 2011 if (debug) { 2012 fprintf(stderr, "failed to set PID %d's CPU affinity errno %d\n", 2013 getpid(),errno); 2014 fflush(stderr); 2015 } 2016 } 2017 } 2018 else { 2019 if (debug) { 2020 fprintf(stderr, 2021 "CPU number larger than pre-compiled limits. Consider a recompile.\n"); 2022 fflush(stderr); 2023 } 2024 } 2025 2026#elif HAVE_BIND_TO_CPU_ID 2027 /* this is the one for Tru64 */ 2028#include <sys/types.h> 2029#include <sys/resource.h> 2030#include <sys/processor.h> 2031 2032 /* really should be checking a return code one of these days. raj 2033 2005/08/31 */ 2034 2035 bind_to_cpu_id(getpid(), mapped_affinity,0); 2036 2037#elif WIN32 2038 2039 { 2040 ULONG_PTR AffinityMask; 2041 ULONG_PTR ProcessAffinityMask; 2042 ULONG_PTR SystemAffinityMask; 2043 2044 if ((mapped_affinity < 0) || 2045 (mapped_affinity > MAXIMUM_PROCESSORS)) { 2046 fprintf(where, 2047 "Invalid processor_affinity specified: %d\n", mapped_affinity); fflush(where); 2048 return; 2049 } 2050 2051 if (!GetProcessAffinityMask( 2052 GetCurrentProcess(), 2053 &ProcessAffinityMask, 2054 &SystemAffinityMask)) 2055 { 2056 perror("GetProcessAffinityMask failed"); 2057 fflush(stderr); 2058 exit(1); 2059 } 2060 2061 AffinityMask = (ULONG_PTR)1 << mapped_affinity; 2062 2063 if (AffinityMask & ProcessAffinityMask) { 2064 if (!SetThreadAffinityMask( GetCurrentThread(), AffinityMask)) { 2065 perror("SetThreadAffinityMask failed"); 2066 fflush(stderr); 2067 } 2068 } else if (debug) { 2069 fprintf(where, 2070 "Processor affinity set to CPU# %d\n", mapped_affinity); 2071 fflush(where); 2072 } 2073 } 2074 2075#else 2076 if (debug) { 2077 fprintf(where, 2078 "Processor affinity not available for this platform!\n"); 2079 fflush(where); 2080 } 2081#endif 2082} 2083 2084 2085/* 2086 * Sets a socket to non-blocking operation. 2087 */ 2088int 2089set_nonblock (SOCKET sock) 2090{ 2091#ifdef WIN32 2092 unsigned long flags = 1; 2093 return (ioctlsocket(sock, FIONBIO, &flags) != SOCKET_ERROR); 2094#else 2095 return (fcntl(sock, F_SETFL, O_NONBLOCK) != -1); 2096#endif 2097} 2098 2099 2100 2101 /***********************************************************************/ 2102 /* */ 2103 /* send_request() */ 2104 /* */ 2105 /* send a netperf request on the control socket to the remote half of */ 2106 /* the connection. to get us closer to intervendor interoperability, */ 2107 /* we will call htonl on each of the int that compose the message to */ 2108 /* be sent. the server-half of the connection will call the ntohl */ 2109 /* routine to undo any changes that may have been made... */ 2110 /* */ 2111 /***********************************************************************/ 2112 2113void 2114send_request() 2115{ 2116 int counter=0; 2117 2118 /* display the contents of the request if the debug level is high */ 2119 /* enough. otherwise, just send the darned thing ;-) */ 2120 2121 if (debug > 1) { 2122 fprintf(where,"entered send_request...contents before htonl:\n"); 2123 dump_request(); 2124 } 2125 2126 /* pass the processor affinity request value to netserver */ 2127 /* this is a kludge and I know it. sgb 8/11/04 */ 2128 2129 netperf_request.content.dummy = remote_proc_affinity; 2130 2131 /* put the entire request array into network order. We do this */ 2132 /* arbitrarily rather than trying to figure-out just how much */ 2133 /* of the request array contains real information. this should */ 2134 /* be simpler, and at any rate, the performance of sending */ 2135 /* control messages for this benchmark is not of any real */ 2136 /* concern. */ 2137 2138 for (counter=0;counter < sizeof(netperf_request)/4; counter++) { 2139 request_array[counter] = htonl(request_array[counter]); 2140 } 2141 2142 if (debug > 1) { 2143 fprintf(where,"send_request...contents after htonl:\n"); 2144 dump_request(); 2145 2146 fprintf(where, 2147 "\nsend_request: about to send %u bytes from %p\n", 2148 sizeof(netperf_request), 2149 &netperf_request); 2150 fflush(where); 2151 } 2152 2153 if (send(netlib_control, 2154 (char *)&netperf_request, 2155 sizeof(netperf_request), 2156 0) != sizeof(netperf_request)) { 2157 perror("send_request: send call failure"); 2158 2159 exit(1); 2160 } 2161} 2162 2163/***********************************************************************/ 2164 /* */ 2165 /* send_response() */ 2166 /* */ 2167 /* send a netperf response on the control socket to the remote half of */ 2168 /* the connection. to get us closer to intervendor interoperability, */ 2169 /* we will call htonl on each of the int that compose the message to */ 2170 /* be sent. the other half of the connection will call the ntohl */ 2171 /* routine to undo any changes that may have been made... */ 2172 /* */ 2173 /***********************************************************************/ 2174 2175void 2176send_response() 2177{ 2178 int counter=0; 2179 int bytes_sent; 2180 2181 /* display the contents of the request if the debug level is high */ 2182 /* enough. otherwise, just send the darned thing ;-) */ 2183 2184 if (debug > 1) { 2185 fprintf(where, 2186 "send_response: contents of %u ints before htonl\n", 2187 sizeof(netperf_response)/4); 2188 dump_response(); 2189 } 2190 2191 /* put the entire response_array into network order. We do this */ 2192 /* arbitrarily rather than trying to figure-out just how much of the */ 2193 /* request array contains real information. this should be simpler, */ 2194 /* and at any rate, the performance of sending control messages for */ 2195 /* this benchmark is not of any real concern. */ 2196 2197 for (counter=0;counter < sizeof(netperf_response)/4; counter++) { 2198 response_array[counter] = htonl(response_array[counter]); 2199 } 2200 2201 if (debug > 1) { 2202 fprintf(where, 2203 "send_response: contents after htonl\n"); 2204 dump_response(); 2205 fprintf(where, 2206 "about to send %u bytes from %p\n", 2207 sizeof(netperf_response), 2208 &netperf_response); 2209 fflush(where); 2210 } 2211 2212 /*KC*/ 2213 if ((bytes_sent = send(server_sock, 2214 (char *)&netperf_response, 2215 sizeof(netperf_response), 2216 0)) != sizeof(netperf_response)) { 2217 perror("send_response: send call failure"); 2218 fprintf(where, "BytesSent: %d\n", bytes_sent); 2219 exit(1); 2220 } 2221 2222} 2223 2224 /***********************************************************************/ 2225 /* */ 2226 /* recv_request() */ 2227 /* */ 2228 /* receive the remote's request on the control socket. we will put */ 2229 /* the entire response into host order before giving it to the */ 2230 /* calling routine. hopefully, this will go most of the way to */ 2231 /* insuring intervendor interoperability. if there are any problems, */ 2232 /* we will just punt the entire situation. */ 2233 /* */ 2234 /***********************************************************************/ 2235 2236void 2237recv_request() 2238{ 2239int tot_bytes_recvd, 2240 bytes_recvd, 2241 bytes_left; 2242char *buf = (char *)&netperf_request; 2243int buflen = sizeof(netperf_request); 2244int counter; 2245 2246tot_bytes_recvd = 0; 2247 bytes_recvd = 0; /* nt_lint; bytes_recvd uninitialized if buflen == 0 */ 2248bytes_left = buflen; 2249while ((tot_bytes_recvd != buflen) && 2250 ((bytes_recvd = recv(server_sock, buf, bytes_left,0)) > 0 )) { 2251 tot_bytes_recvd += bytes_recvd; 2252 buf += bytes_recvd; 2253 bytes_left -= bytes_recvd; 2254} 2255 2256/* put the request into host order */ 2257 2258for (counter = 0; counter < sizeof(netperf_request)/sizeof(int); counter++) { 2259 request_array[counter] = ntohl(request_array[counter]); 2260} 2261 2262if (debug) { 2263 fprintf(where, 2264 "recv_request: received %d bytes of request.\n", 2265 tot_bytes_recvd); 2266 fflush(where); 2267} 2268 2269if (bytes_recvd == SOCKET_ERROR) { 2270 Print_errno(where, 2271 "recv_request: error on recv"); 2272 fflush(where); 2273 exit(1); 2274} 2275 2276if (bytes_recvd == 0) { 2277 /* the remote has shutdown the control connection, we should shut it */ 2278 /* down as well and exit */ 2279 2280 if (debug) { 2281 fprintf(where, 2282 "recv_request: remote requested shutdown of control\n"); 2283 fflush(where); 2284 } 2285 2286 if (netlib_control != INVALID_SOCKET) { 2287 shutdown_control(); 2288 } 2289 exit(0); 2290} 2291 2292if (tot_bytes_recvd < buflen) { 2293 if (debug > 1) 2294 dump_request(); 2295 2296 fprintf(where, 2297 "recv_request: partial request received of %d bytes\n", 2298 tot_bytes_recvd); 2299 fflush(where); 2300 exit(1); 2301} 2302 2303 if (debug > 1) { 2304 dump_request(); 2305 } 2306 2307 /* get the processor affinity request value from netperf */ 2308 /* this is a kludge and I know it. sgb 8/11/04 */ 2309 2310 local_proc_affinity = netperf_request.content.dummy; 2311 2312 if (local_proc_affinity != -1) { 2313 bind_to_specific_processor(local_proc_affinity,0); 2314 } 2315 2316} 2317 2318 /* 2319 2320 recv_response_timed() 2321 2322 receive the remote's response on the control socket. we will put the 2323 entire response into host order before giving it to the calling 2324 routine. hopefully, this will go most of the way to insuring 2325 intervendor interoperability. if there are any problems, we will just 2326 punt the entire situation. 2327 2328 The call to select at the beginning is to get us out of hang 2329 situations where the remote gives-up but we don't find-out about 2330 it. This seems to happen only rarely, but it would be nice to be 2331 somewhat robust ;-) 2332 2333 The "_timed" part is to allow the caller to add (or I suppose 2334 subtract) from the length of timeout on the select call. this was 2335 added since not all the CPU utilization mechanisms require a 40 2336 second calibration, and we used to have an aribtrary 40 second sleep 2337 in "calibrate_remote_cpu" - since we don't _always_ need that, we 2338 want to simply add 40 seconds to the select() timeout from that call, 2339 but don't want to change all the "recv_response" calls in the code 2340 right away. sooo, we push the functionality of the old 2341 recv_response() into a new recv_response_timed(addl_timout) call, and 2342 have recv_response() call recv_response_timed(0). raj 2005-05-16 2343 2344 */ 2345 2346 2347void 2348recv_response_timed(int addl_time) 2349{ 2350int tot_bytes_recvd, 2351 bytes_recvd = 0, 2352 bytes_left; 2353char *buf = (char *)&netperf_response; 2354int buflen = sizeof(netperf_response); 2355int counter; 2356 2357 /* stuff for select, use fd_set for better compliance */ 2358fd_set readfds; 2359struct timeval timeout; 2360 2361tot_bytes_recvd = 0; 2362bytes_left = buflen; 2363 2364/* zero out the response structure */ 2365 2366/* BUG FIX SJB 2/4/93 - should be < not <= */ 2367for (counter = 0; counter < sizeof(netperf_response)/sizeof(int); counter++) { 2368 response_array[counter] = 0; 2369} 2370 2371 /* we only select once. it is assumed that if the response is split */ 2372 /* (which should not be happening, that we will receive the whole */ 2373 /* thing and not have a problem ;-) */ 2374 2375FD_ZERO(&readfds); 2376FD_SET(netlib_control,&readfds); 2377timeout.tv_sec = 120 + addl_time; /* wait at least two minutes 2378 before punting - the USE_LOOPER 2379 CPU stuff may cause remote's to 2380 have a bit longer time of it 2381 than 60 seconds would allow. 2382 triggered by fix from Jeff 2383 Dwork. */ 2384timeout.tv_usec = 0; 2385 2386 /* select had better return one, or there was either a problem or a */ 2387 /* timeout... */ 2388 2389if ((counter = select(FD_SETSIZE, 2390 &readfds, 2391 0, 2392 0, 2393 &timeout)) != 1) { 2394 fprintf(where, 2395 "netperf: receive_response: no response received. errno %d counter %d\n", 2396 errno, 2397 counter); 2398 exit(1); 2399} 2400 2401while ((tot_bytes_recvd != buflen) && 2402 ((bytes_recvd = recv(netlib_control, buf, bytes_left,0)) > 0 )) { 2403 tot_bytes_recvd += bytes_recvd; 2404 buf += bytes_recvd; 2405 bytes_left -= bytes_recvd; 2406} 2407 2408if (debug) { 2409 fprintf(where,"recv_response: received a %d byte response\n", 2410 tot_bytes_recvd); 2411 fflush(where); 2412} 2413 2414/* put the response into host order */ 2415 2416for (counter = 0; counter < sizeof(netperf_response)/sizeof(int); counter++) { 2417 response_array[counter] = ntohl(response_array[counter]); 2418} 2419 2420if (bytes_recvd == SOCKET_ERROR) { 2421 perror("recv_response"); 2422 exit(1); 2423} 2424if (tot_bytes_recvd < buflen) { 2425 fprintf(stderr, 2426 "recv_response: partial response received: %d bytes\n", 2427 tot_bytes_recvd); 2428 fflush(stderr); 2429 if (debug > 1) 2430 dump_response(); 2431 exit(1); 2432} 2433if (debug > 1) { 2434 dump_response(); 2435} 2436} 2437 2438void 2439recv_response() 2440{ 2441 recv_response_timed(0); 2442} 2443 2444 2445 2446#if defined(USE_PSTAT) || defined (USE_SYSCTL) 2447int 2448hi_32(big_int) 2449 long long *big_int; 2450{ 2451 union overlay_u { 2452 long long dword; 2453 long words[2]; 2454 } *overlay; 2455 2456 overlay = (union overlay_u *)big_int; 2457 /* on those systems which are byte swapped, we really wish to */ 2458 /* return words[1] - at least I think so - raj 4/95 */ 2459 if (htonl(1L) == 1L) { 2460 /* we are a "normal" :) machine */ 2461 return(overlay->words[0]); 2462 } 2463 else { 2464 return(overlay->words[1]); 2465 } 2466} 2467 2468int 2469lo_32(big_int) 2470 long long *big_int; 2471{ 2472 union overlay_u { 2473 long long dword; 2474 long words[2]; 2475 } *overlay; 2476 2477 overlay = (union overlay_u *)big_int; 2478 /* on those systems which are byte swapped, we really wish to */ 2479 /* return words[0] - at least I think so - raj 4/95 */ 2480 if (htonl(1L) == 1L) { 2481 /* we are a "normal" :) machine */ 2482 return(overlay->words[1]); 2483 } 2484 else { 2485 return(overlay->words[0]); 2486 } 2487} 2488 2489#endif /* USE_PSTAT || USE_SYSCTL */ 2490 2491 2492void libmain() 2493{ 2494fprintf(where,"hello world\n"); 2495fprintf(where,"debug: %d\n",debug); 2496} 2497 2498 2499void 2500set_sock_buffer (SOCKET sd, enum sock_buffer which, int requested_size, int *effective_sizep) 2501{ 2502#ifdef SO_SNDBUF 2503 int optname = (which == SEND_BUFFER) ? SO_SNDBUF : SO_RCVBUF; 2504 netperf_socklen_t sock_opt_len; 2505 2506 /* seems that under Windows, setting a value of zero is how one 2507 tells the stack you wish to enable copy-avoidance. Knuth only 2508 knows what it will do on other stacks, but it might be 2509 interesting to find-out, so we won't bother #ifdef'ing the change 2510 to allow asking for 0 bytes. Courtesy of SAF, 2007-05 raj 2511 2007-05-31 */ 2512 if (requested_size >= 0) { 2513 if (setsockopt(sd, SOL_SOCKET, optname, 2514 (char *)&requested_size, sizeof(int)) < 0) { 2515 fprintf(where, "netperf: set_sock_buffer: %s option: errno %d\n", 2516 (which == SEND_BUFFER) ? "SO_SNDBUF" : "SO_RCVBUF", 2517 errno); 2518 fflush(where); 2519 exit(1); 2520 } 2521 if (debug > 1) { 2522 fprintf(where, "netperf: set_sock_buffer: %s of %d requested.\n", 2523 (which == SEND_BUFFER) ? "SO_SNDBUF" : "SO_RCVBUF", 2524 requested_size); 2525 fflush(where); 2526 } 2527 } 2528 2529 /* Now, we will find-out what the size actually became, and report */ 2530 /* that back to the user. If the call fails, we will just report a -1 */ 2531 /* back to the initiator for the recv buffer size. */ 2532 2533 sock_opt_len = sizeof(netperf_socklen_t); 2534 if (getsockopt(sd, SOL_SOCKET, optname, (char *)effective_sizep, 2535 &sock_opt_len) < 0) { 2536 fprintf(where, "netperf: set_sock_buffer: getsockopt %s: errno %d\n", 2537 (which == SEND_BUFFER) ? "SO_SNDBUF" : "SO_RCVBUF", errno); 2538 fflush(where); 2539 *effective_sizep = -1; 2540 } 2541 2542 if (debug) { 2543 fprintf(where, "netperf: set_sock_buffer: " 2544 "%s socket size determined to be %d\n", 2545 (which == SEND_BUFFER) ? "send" : "receive", *effective_sizep); 2546 fflush(where); 2547 } 2548#else /* SO_SNDBUF */ 2549 *effective_size = -1; 2550#endif /* SO_SNDBUF */ 2551} 2552 2553void 2554dump_addrinfo(FILE *dumploc, struct addrinfo *info, 2555 char *host, char *port, int family) 2556{ 2557 struct sockaddr *ai_addr; 2558 struct addrinfo *temp; 2559 temp=info; 2560 2561 fprintf(dumploc, "getaddrinfo returned the following for host '%s' ", host); 2562 fprintf(dumploc, "port '%s' ", port); 2563 fprintf(dumploc, "family %s\n", inet_ftos(family)); 2564 while (temp) { 2565 /* seems that Solaris 10 GA bits will not give a canonical name 2566 for ::0 or 0.0.0.0, and their fprintf() cannot deal with a null 2567 pointer, so we have to check for a null pointer. probably a 2568 safe thing to do anyway, eventhough it was not necessary on 2569 linux or hp-ux. raj 2005-02-09 */ 2570 if (temp->ai_canonname) { 2571 fprintf(dumploc, 2572 "\tcannonical name: '%s'\n",temp->ai_canonname); 2573 } 2574 else { 2575 fprintf(dumploc, 2576 "\tcannonical name: '%s'\n","(nil)"); 2577 } 2578 fprintf(dumploc, 2579 "\tflags: %x family: %s: socktype: %s protocol %s addrlen %d\n", 2580 temp->ai_flags, 2581 inet_ftos(temp->ai_family), 2582 inet_ttos(temp->ai_socktype), 2583 inet_ptos(temp->ai_protocol), 2584 temp->ai_addrlen); 2585 ai_addr = temp->ai_addr; 2586 if (ai_addr != NULL) { 2587 fprintf(dumploc, 2588 "\tsa_family: %s sadata: %d %d %d %d %d %d\n", 2589 inet_ftos(ai_addr->sa_family), 2590 (u_char)ai_addr->sa_data[0], 2591 (u_char)ai_addr->sa_data[1], 2592 (u_char)ai_addr->sa_data[2], 2593 (u_char)ai_addr->sa_data[3], 2594 (u_char)ai_addr->sa_data[4], 2595 (u_char)ai_addr->sa_data[5]); 2596 } 2597 temp = temp->ai_next; 2598 } 2599 fflush(dumploc); 2600} 2601 2602/* 2603 establish_control() 2604 2605set-up the control connection between netperf and the netserver so we 2606can actually run some tests. if we cannot establish the control 2607connection, that may or may not be a good thing, so we will let the 2608caller decide what to do. 2609 2610to assist with pesky end-to-end-unfriendly things like firewalls, we 2611allow the caller to specify both the remote hostname and port, and the 2612local addressing info. i believe that in theory it is possible to 2613have an IPv4 endpoint and an IPv6 endpoint communicate with one 2614another, but for the time being, we are only going to take-in one 2615requested address family parameter. this means that the only way 2616(iirc) that we might get a mixed-mode connection would be if the 2617address family is specified as AF_UNSPEC, and getaddrinfo() returns 2618different families for the local and server names. 2619 2620the "names" can also be IP addresses in ASCII string form. 2621 2622raj 2003-02-27 */ 2623 2624SOCKET 2625establish_control_internal(char *hostname, 2626 char *port, 2627 int remfam, 2628 char *localhost, 2629 char *localport, 2630 int locfam) 2631{ 2632 int not_connected; 2633 SOCKET control_sock; 2634 int count; 2635 int error; 2636 2637 struct addrinfo hints; 2638 struct addrinfo *local_res; 2639 struct addrinfo *remote_res; 2640 struct addrinfo *local_res_temp; 2641 struct addrinfo *remote_res_temp; 2642 2643 if (debug) { 2644 fprintf(where, 2645 "establish_control called with host '%s' port '%s' remfam %s\n", 2646 hostname, 2647 port, 2648 inet_ftos(remfam)); 2649 fprintf(where, 2650 "\t\tlocal '%s' port '%s' locfam %s\n", 2651 localhost, 2652 localport, 2653 inet_ftos(locfam)); 2654 fflush(where); 2655 } 2656 2657 /* first, we do the remote */ 2658 memset(&hints, 0, sizeof(hints)); 2659 hints.ai_family = remfam; 2660 hints.ai_socktype = SOCK_STREAM; 2661 hints.ai_protocol = IPPROTO_TCP; 2662 hints.ai_flags = 0|AI_CANONNAME; 2663 count = 0; 2664 do { 2665 error = getaddrinfo((char *)hostname, 2666 (char *)port, 2667 &hints, 2668 &remote_res); 2669 count += 1; 2670 if (error == EAI_AGAIN) { 2671 if (debug) { 2672 fprintf(where,"Sleeping on getaddrinfo EAI_AGAIN\n"); 2673 fflush(where); 2674 } 2675 sleep(1); 2676 } 2677 } while ((error == EAI_AGAIN) && (count <= 5)); 2678 2679 if (error) { 2680 printf("establish control: could not resolve remote '%s' port '%s' af %s", 2681 hostname, 2682 port, 2683 inet_ftos(remfam)); 2684 printf("\n\tgetaddrinfo returned %d %s\n", 2685 error, 2686 gai_strerror(error)); 2687 return(INVALID_SOCKET); 2688 } 2689 2690 if (debug) { 2691 dump_addrinfo(where, remote_res, hostname, port, remfam); 2692 } 2693 2694 /* now we do the local */ 2695 memset(&hints, 0, sizeof(hints)); 2696 hints.ai_family = locfam; 2697 hints.ai_socktype = SOCK_STREAM; 2698 hints.ai_protocol = IPPROTO_TCP; 2699 hints.ai_flags = AI_PASSIVE|AI_CANONNAME; 2700 count = 0; 2701 do { 2702 count += 1; 2703 error = getaddrinfo((char *)localhost, 2704 (char *)localport, 2705 &hints, 2706 &local_res); 2707 if (error == EAI_AGAIN) { 2708 if (debug) { 2709 fprintf(where, 2710 "Sleeping on getaddrinfo(%s,%s) EAI_AGAIN count %d \n", 2711 localhost, 2712 localport, 2713 count); 2714 fflush(where); 2715 } 2716 sleep(1); 2717 } 2718 } while ((error == EAI_AGAIN) && (count <= 5)); 2719 2720 if (error) { 2721 printf("establish control: could not resolve local '%s' port '%s' af %s", 2722 localhost, 2723 localport, 2724 inet_ftos(locfam)); 2725 printf("\n\tgetaddrinfo returned %d %s\n", 2726 error, 2727 gai_strerror(error)); 2728 return(INVALID_SOCKET); 2729 } 2730 2731 if (debug) { 2732 dump_addrinfo(where, local_res, localhost, localport, locfam); 2733 } 2734 2735 not_connected = 1; 2736 local_res_temp = local_res; 2737 remote_res_temp = remote_res; 2738 /* we want to loop through all the possibilities. looping on the 2739 local addresses will be handled within the while loop. I suppose 2740 these is some more "C-expert" way to code this, but it has not 2741 lept to mind just yet :) raj 2003-02024 */ 2742 2743 while (remote_res_temp != NULL) { 2744 2745 /* I am guessing that we should use the address family of the 2746 local endpoint, and we will not worry about mixed family types 2747 - presumeably the stack or other transition mechanisms will be 2748 able to deal with that for us. famous last words :) raj 2003-02-26 */ 2749 control_sock = socket(local_res_temp->ai_family, 2750 SOCK_STREAM, 2751 0); 2752 if (control_sock == INVALID_SOCKET) { 2753 /* at some point we'll need a more generic "display error" 2754 message for when/if we use GUIs and the like. unlike a bind 2755 or connect failure, failure to allocate a socket is 2756 "immediately fatal" and so we return to the caller. raj 2003-02-24 */ 2757 if (debug) { 2758 perror("establish_control: unable to allocate control socket"); 2759 } 2760 return(INVALID_SOCKET); 2761 } 2762 2763 /* if we are going to control the local enpoint addressing, we 2764 need to call bind. of course, we should probably be setting one 2765 of the SO_REUSEmumble socket options? raj 2005-02-04 */ 2766 if (bind(control_sock, 2767 local_res_temp->ai_addr, 2768 local_res_temp->ai_addrlen) == 0) { 2769 if (debug) { 2770 fprintf(where, 2771 "bound control socket to %s and %s\n", 2772 localhost, 2773 localport); 2774 } 2775 2776 if (connect(control_sock, 2777 remote_res_temp->ai_addr, 2778 remote_res_temp->ai_addrlen) == 0) { 2779 /* we have successfully connected to the remote netserver */ 2780 if (debug) { 2781 fprintf(where, 2782 "successful connection to remote netserver at %s and %s\n", 2783 hostname, 2784 port); 2785 } 2786 not_connected = 0; 2787 /* this should get us out of the while loop */ 2788 break; 2789 } else { 2790 /* the connect call failed */ 2791 if (debug) { 2792 fprintf(where, 2793 "establish_control: connect failed, errno %d %s\n", 2794 errno, 2795 strerror(errno)); 2796 fprintf(where, " trying next address combination\n"); 2797 fflush(where); 2798 } 2799 } 2800 } 2801 else { 2802 /* the bind failed */ 2803 if (debug) { 2804 fprintf(where, 2805 "establish_control: bind failed, errno %d %s\n", 2806 errno, 2807 strerror(errno)); 2808 fprintf(where, " trying next address combination\n"); 2809 fflush(where); 2810 } 2811 } 2812 2813 if ((local_res_temp = local_res_temp->ai_next) == NULL) { 2814 /* wrap the local and move to the next server, don't forget to 2815 close the current control socket. raj 2003-02-24 */ 2816 local_res_temp = local_res; 2817 /* the outer while conditions will deal with the case when we 2818 get to the end of all the possible remote addresses. */ 2819 remote_res_temp = remote_res_temp->ai_next; 2820 /* it is simplest here to just close the control sock. since 2821 this is not a performance critical section of code, we 2822 don't worry about overheads for socket allocation or 2823 close. raj 2003-02-24 */ 2824 } 2825 close(control_sock); 2826 } 2827 2828 /* we no longer need the addrinfo stuff */ 2829 freeaddrinfo(local_res); 2830 freeaddrinfo(remote_res); 2831 2832 /* so, we are either connected or not */ 2833 if (not_connected) { 2834 fprintf(where, "establish control: are you sure there is a netserver listening on %s at port %s?\n",hostname,port); 2835 fflush(where); 2836 return(INVALID_SOCKET); 2837 } 2838 /* at this point, we are connected. we probably want some sort of 2839 version check with the remote at some point. raj 2003-02-24 */ 2840 return(control_sock); 2841} 2842 2843void 2844establish_control(char *hostname, 2845 char *port, 2846 int remfam, 2847 char *localhost, 2848 char *localport, 2849 int locfam) 2850 2851{ 2852 2853 netlib_control = establish_control_internal(hostname, 2854 port, 2855 remfam, 2856 localhost, 2857 localport, 2858 locfam); 2859 if (netlib_control == INVALID_SOCKET) { 2860 fprintf(where, 2861 "establish_control could not establish the control connection from %s port %s address family %s to %s port %s address family %s\n", 2862 localhost,localport,inet_ftos(locfam), 2863 hostname,port,inet_ftos(remfam)); 2864 fflush(where); 2865 exit(INVALID_SOCKET); 2866 } 2867} 2868 2869 2870 2871 2872 /***********************************************************************/ 2873 /* */ 2874 /* get_id() */ 2875 /* */ 2876 /* Return a string to the calling routine that contains the */ 2877 /* identifying information for the host we are running on. This */ 2878 /* information will then either be displayed locally, or returned to */ 2879 /* a remote caller for display there. */ 2880 /* */ 2881 /***********************************************************************/ 2882 2883char * 2884get_id() 2885{ 2886 static char id_string[80]; 2887#ifdef WIN32 2888char system_name[MAX_COMPUTERNAME_LENGTH+1] ; 2889DWORD name_len = MAX_COMPUTERNAME_LENGTH + 1 ; 2890#else 2891struct utsname system_name; 2892#endif /* WIN32 */ 2893 2894#ifdef WIN32 2895 SYSTEM_INFO SystemInfo; 2896 GetSystemInfo( &SystemInfo ) ; 2897 if ( !GetComputerName(system_name , &name_len) ) 2898 strcpy(system_name , "no_name") ; 2899#else 2900 if (uname(&system_name) <0) { 2901 perror("identify_local: uname"); 2902 exit(1); 2903 } 2904#endif /* WIN32 */ 2905 2906 snprintf(id_string, sizeof(id_string), 2907#ifdef WIN32 2908 "%-15s%-15s%d.%d%d", 2909 "Windows NT", 2910 system_name , 2911 GetVersion() & 0xFF , 2912 GetVersion() & 0xFF00 , 2913 SystemInfo.dwProcessorType 2914 2915#else 2916 "%-15s%-15s%-15s%-15s%-15s", 2917 system_name.sysname, 2918 system_name.nodename, 2919 system_name.release, 2920 system_name.version, 2921 system_name.machine 2922#endif /* WIN32 */ 2923 ); 2924 return (id_string); 2925} 2926 2927 2928 /***********************************************************************/ 2929 /* */ 2930 /* identify_local() */ 2931 /* */ 2932 /* Display identifying information about the local host to the user. */ 2933 /* At first release, this information will be the same as that which */ 2934 /* is returned by the uname -a command, with the exception of the */ 2935 /* idnumber field, which seems to be a non-POSIX item, and hence */ 2936 /* non-portable. */ 2937 /* */ 2938 /***********************************************************************/ 2939 2940void 2941identify_local() 2942{ 2943 2944char *local_id; 2945 2946local_id = get_id(); 2947 2948fprintf(where,"Local Information \n\ 2949Sysname Nodename Release Version Machine\n"); 2950 2951fprintf(where,"%s\n", 2952 local_id); 2953 2954} 2955 2956 2957 /***********************************************************************/ 2958 /* */ 2959 /* identify_remote() */ 2960 /* */ 2961 /* Display identifying information about the remote host to the user. */ 2962 /* At first release, this information will be the same as that which */ 2963 /* is returned by the uname -a command, with the exception of the */ 2964 /* idnumber field, which seems to be a non-POSIX item, and hence */ 2965 /* non-portable. A request is sent to the remote side, which will */ 2966 /* return a string containing the utsname information in a */ 2967 /* pre-formatted form, which is then displayed after the header. */ 2968 /* */ 2969 /***********************************************************************/ 2970 2971void 2972identify_remote() 2973{ 2974 2975char *remote_id=""; 2976 2977/* send a request for node info to the remote */ 2978netperf_request.content.request_type = NODE_IDENTIFY; 2979 2980send_request(); 2981 2982/* and now wait for the reply to come back */ 2983 2984recv_response(); 2985 2986if (netperf_response.content.serv_errno) { 2987 Set_errno(netperf_response.content.serv_errno); 2988 perror("identify_remote: on remote"); 2989 exit(1); 2990} 2991 2992fprintf(where,"Remote Information \n\ 2993Sysname Nodename Release Version Machine\n"); 2994 2995fprintf(where,"%s", 2996 remote_id); 2997} 2998 2999void 3000cpu_start(int measure_cpu) 3001{ 3002 3003 gettimeofday(&time1, 3004 &tz); 3005 3006 if (measure_cpu) { 3007 cpu_util_init(); 3008 measuring_cpu = 1; 3009 cpu_method = get_cpu_method(); 3010 cpu_start_internal(); 3011 } 3012} 3013 3014 3015void 3016cpu_stop(int measure_cpu, float *elapsed) 3017 3018{ 3019 3020 int sec, 3021 usec; 3022 3023 if (measure_cpu) { 3024 cpu_stop_internal(); 3025 cpu_util_terminate(); 3026 } 3027 3028 gettimeofday(&time2, 3029 &tz); 3030 3031 if (time2.tv_usec < time1.tv_usec) { 3032 time2.tv_usec += 1000000; 3033 time2.tv_sec -= 1; 3034 } 3035 3036 sec = time2.tv_sec - time1.tv_sec; 3037 usec = time2.tv_usec - time1.tv_usec; 3038 lib_elapsed = (float)sec + ((float)usec/(float)1000000.0); 3039 3040 *elapsed = lib_elapsed; 3041 3042} 3043 3044 3045double 3046calc_thruput_interval(double units_received,double elapsed) 3047 3048{ 3049 double divisor; 3050 3051 /* We will calculate the thruput in libfmt units/second */ 3052 switch (libfmt) { 3053 case 'K': 3054 divisor = 1024.0; 3055 break; 3056 case 'M': 3057 divisor = 1024.0 * 1024.0; 3058 break; 3059 case 'G': 3060 divisor = 1024.0 * 1024.0 * 1024.0; 3061 break; 3062 case 'k': 3063 divisor = 1000.0 / 8.0; 3064 break; 3065 case 'm': 3066 divisor = 1000.0 * 1000.0 / 8.0; 3067 break; 3068 case 'g': 3069 divisor = 1000.0 * 1000.0 * 1000.0 / 8.0; 3070 break; 3071 3072 default: 3073 divisor = 1024.0; 3074 } 3075 3076 return (units_received / divisor / elapsed); 3077 3078} 3079 3080double 3081calc_thruput(double units_received) 3082 3083{ 3084 return(calc_thruput_interval(units_received,lib_elapsed)); 3085} 3086 3087/* these "_omni" versions are ones which understand 'x' as a unit, 3088 meaning transactions/s. we have a separate routine rather than 3089 convert the existing routine so we don't have to go and change 3090 _all_ the nettest_foo.c files at one time. raj 2007-06-08 */ 3091 3092double 3093calc_thruput_interval_omni(double units_received,double elapsed) 3094 3095{ 3096 double divisor; 3097 3098 /* We will calculate the thruput in libfmt units/second */ 3099 switch (libfmt) { 3100 case 'K': 3101 divisor = 1024.0; 3102 break; 3103 case 'M': 3104 divisor = 1024.0 * 1024.0; 3105 break; 3106 case 'G': 3107 divisor = 1024.0 * 1024.0 * 1024.0; 3108 break; 3109 case 'k': 3110 divisor = 1000.0 / 8.0; 3111 break; 3112 case 'm': 3113 divisor = 1000.0 * 1000.0 / 8.0; 3114 break; 3115 case 'g': 3116 divisor = 1000.0 * 1000.0 * 1000.0 / 8.0; 3117 break; 3118 case 'x': 3119 divisor = 1.0; 3120 break; 3121 3122 default: 3123 fprintf(where, 3124 "WARNING calc_throughput_internal_omni: unknown units %c\n", 3125 libfmt); 3126 fflush(where); 3127 divisor = 1024.0; 3128 } 3129 3130 return (units_received / divisor / elapsed); 3131 3132} 3133 3134double 3135calc_thruput_omni(double units_received) 3136 3137{ 3138 return(calc_thruput_interval_omni(units_received,lib_elapsed)); 3139} 3140 3141 3142 3143 3144 3145float 3146calc_cpu_util(float elapsed_time) 3147{ 3148 return(calc_cpu_util_internal(elapsed_time)); 3149} 3150 3151float 3152calc_service_demand_internal(double unit_divisor, 3153 double units_sent, 3154 float elapsed_time, 3155 float cpu_utilization, 3156 int num_cpus) 3157 3158{ 3159 3160 double service_demand; 3161 double thruput; 3162 3163 if (debug) { 3164 fprintf(where,"calc_service_demand called: units_sent = %f\n", 3165 units_sent); 3166 fprintf(where," elapsed_time = %f\n", 3167 elapsed_time); 3168 fprintf(where," cpu_util = %f\n", 3169 cpu_utilization); 3170 fprintf(where," num cpu = %d\n", 3171 num_cpus); 3172 fflush(where); 3173 } 3174 3175 if (num_cpus == 0) num_cpus = lib_num_loc_cpus; 3176 3177 if (elapsed_time == 0.0) { 3178 elapsed_time = lib_elapsed; 3179 } 3180 if (cpu_utilization == 0.0) { 3181 cpu_utilization = lib_local_cpu_util; 3182 } 3183 3184 thruput = (units_sent / 3185 (double) unit_divisor / 3186 (double) elapsed_time); 3187 3188 /* on MP systems, it is necessary to multiply the service demand by */ 3189 /* the number of CPU's. at least, I believe that to be the case:) */ 3190 /* raj 10/95 */ 3191 3192 /* thruput has a "per second" component. if we were using 100% ( */ 3193 /* 100.0) of the CPU in a second, that would be 1 second, or 1 */ 3194 /* millisecond, so we multiply cpu_utilization by 10 to go to */ 3195 /* milliseconds, or 10,000 to go to micro seconds. With revision */ 3196 /* 2.1, the service demand measure goes to microseconds per unit. */ 3197 /* raj 12/95 */ 3198 service_demand = (cpu_utilization*10000.0/thruput) * 3199 (float) num_cpus; 3200 3201 if (debug) { 3202 fprintf(where,"calc_service_demand using: units_sent = %f\n", 3203 units_sent); 3204 fprintf(where," elapsed_time = %f\n", 3205 elapsed_time); 3206 fprintf(where," cpu_util = %f\n", 3207 cpu_utilization); 3208 fprintf(where," num cpu = %d\n", 3209 num_cpus); 3210 fprintf(where,"calc_service_demand got: thruput = %f\n", 3211 thruput); 3212 fprintf(where," servdem = %f\n", 3213 service_demand); 3214 fflush(where); 3215 } 3216 return (float)service_demand; 3217} 3218 3219float calc_service_demand(double units_sent, 3220 float elapsed_time, 3221 float cpu_utilization, 3222 int num_cpus) 3223 3224{ 3225 3226 double unit_divisor = (double)1024.0; 3227 3228 return(calc_service_demand_internal(unit_divisor, 3229 units_sent, 3230 elapsed_time, 3231 cpu_utilization, 3232 num_cpus)); 3233} 3234 3235float calc_service_demand_trans(double units_sent, 3236 float elapsed_time, 3237 float cpu_utilization, 3238 int num_cpus) 3239 3240{ 3241 3242 double unit_divisor = (double)1.0; 3243 3244 return(calc_service_demand_internal(unit_divisor, 3245 units_sent, 3246 elapsed_time, 3247 cpu_utilization, 3248 num_cpus)); 3249} 3250 3251 3252 3253float 3254calibrate_local_cpu(float local_cpu_rate) 3255{ 3256 3257 lib_num_loc_cpus = get_num_cpus(); 3258 3259 lib_use_idle = 0; 3260#ifdef USE_LOOPER 3261 cpu_util_init(); 3262 lib_use_idle = 1; 3263#endif /* USE_LOOPER */ 3264 3265 if (local_cpu_rate > 0) { 3266 /* The user think that he knows what the cpu rate is. We assume */ 3267 /* that all the processors of an MP system are essentially the */ 3268 /* same - for this reason we do not have a per processor maxrate. */ 3269 /* if the machine has processors which are different in */ 3270 /* performance, the CPU utilization will be skewed. raj 4/95 */ 3271 lib_local_maxrate = local_cpu_rate; 3272 } 3273 else { 3274 /* if neither USE_LOOPER nor USE_PSTAT are defined, we return a */ 3275 /* 0.0 to indicate that times or getrusage should be used. raj */ 3276 /* 4/95 */ 3277 lib_local_maxrate = (float)0.0; 3278#if defined(USE_PROC_STAT) || defined(USE_LOOPER) || defined(USE_PSTAT) || defined(USE_KSTAT) || defined(USE_PERFSTAT) || defined(USE_SYSCTL) 3279 lib_local_maxrate = calibrate_idle_rate(4,10); 3280#endif 3281 } 3282 return lib_local_maxrate; 3283} 3284 3285 3286float 3287calibrate_remote_cpu() 3288{ 3289 float remrate; 3290 3291 netperf_request.content.request_type = CPU_CALIBRATE; 3292 send_request(); 3293 /* we know that calibration will last at least 40 seconds, so go to */ 3294 /* sleep for that long so the 60 second select in recv_response will */ 3295 /* not pop. raj 7/95 */ 3296 3297 /* we know that CPU calibration may last as long as 40 seconds, so 3298 make sure we "select" for at least that long while looking for 3299 the response. raj 2005-05-16 */ 3300 recv_response_timed(40); 3301 3302 if (netperf_response.content.serv_errno) { 3303 /* initially, silently ignore remote errors and pass */ 3304 /* back a zero to the caller this should allow us to */ 3305 /* mix rev 1.0 and rev 1.1 netperfs... */ 3306 return((float)0.0); 3307 } 3308 else { 3309 /* the rate is the first word of the test_specific data */ 3310 bcopy((char *)netperf_response.content.test_specific_data, 3311 (char *)&remrate, 3312 sizeof(remrate)); 3313 bcopy((char *)netperf_response.content.test_specific_data + sizeof(remrate), 3314 (char *)&lib_num_rem_cpus, 3315 sizeof(lib_num_rem_cpus)); 3316/* remrate = (float) netperf_response.content.test_specific_data[0]; */ 3317 return(remrate); 3318 } 3319} 3320 3321#ifndef WIN32 3322/* WIN32 requires that at least one of the file sets to select be non-null. */ 3323/* Since msec_sleep routine is only called by nettest_dlpi & nettest_unix, */ 3324/* let's duck this issue. */ 3325 3326int 3327msec_sleep( int msecs ) 3328{ 3329 int rval ; 3330 3331 struct timeval timeout; 3332 3333 timeout.tv_sec = msecs / 1000; 3334 timeout.tv_usec = (msecs - (msecs/1000) *1000) * 1000; 3335 if ((rval = select(0, 3336 0, 3337 0, 3338 0, 3339 &timeout))) { 3340 if ( SOCKET_EINTR(rval) ) { 3341 return(1); 3342 } 3343 perror("msec_sleep: select"); 3344 exit(1); 3345 } 3346 return(0); 3347} 3348#endif /* WIN32 */ 3349 3350#ifdef WANT_HISTOGRAM 3351/* hist.c 3352 3353 Given a time difference in microseconds, increment one of 61 3354 different buckets: 3355 3356 0 - 9 in increments of 1 usec 3357 0 - 9 in increments of 10 usecs 3358 0 - 9 in increments of 100 usecs 3359 1 - 9 in increments of 1 msec 3360 1 - 9 in increments of 10 msecs 3361 1 - 9 in increments of 100 msecs 3362 1 - 9 in increments of 1 sec 3363 1 - 9 in increments of 10 sec 3364 > 100 secs 3365 3366 This will allow any time to be recorded to within an accuracy of 3367 10%, and provides a compact representation for capturing the 3368 distribution of a large number of time differences (e.g. 3369 request-response latencies). 3370 3371 Colin Low 10/6/93 3372 Rick Jones 2004-06-15 extend to unit and ten usecs 3373*/ 3374 3375/* #include "sys.h" */ 3376 3377/*#define HIST_TEST*/ 3378 3379HIST 3380HIST_new(void){ 3381 HIST h; 3382 if((h = (HIST) malloc(sizeof(struct histogram_struct))) == NULL) { 3383 perror("HIST_new - malloc failed"); 3384 exit(1); 3385 } 3386 HIST_clear(h); 3387 return h; 3388} 3389 3390void 3391HIST_clear(HIST h){ 3392 int i; 3393 for(i = 0; i < 10; i++){ 3394 h->unit_usec[i] = 0; 3395 h->ten_usec[i] = 0; 3396 h->hundred_usec[i] = 0; 3397 h->unit_msec[i] = 0; 3398 h->ten_msec[i] = 0; 3399 h->hundred_msec[i] = 0; 3400 h->unit_sec[i] = 0; 3401 h->ten_sec[i] = 0; 3402 } 3403 h->ridiculous = 0; 3404 h->total = 0; 3405} 3406 3407void 3408HIST_add(register HIST h, int time_delta){ 3409 register int val; 3410 h->total++; 3411 val = time_delta; 3412 if(val <= 9) h->unit_usec[val]++; 3413 else { 3414 val = val/10; 3415 if(val <= 9) h->ten_usec[val]++; 3416 else { 3417 val = val/10; 3418 if(val <= 9) h->hundred_usec[val]++; 3419 else { 3420 val = val/10; 3421 if(val <= 9) h->unit_msec[val]++; 3422 else { 3423 val = val/10; 3424 if(val <= 9) h->ten_msec[val]++; 3425 else { 3426 val = val/10; 3427 if(val <= 9) h->hundred_msec[val]++; 3428 else { 3429 val = val/10; 3430 if(val <= 9) h->unit_sec[val]++; 3431 else { 3432 val = val/10; 3433 if(val <= 9) h->ten_sec[val]++; 3434 else h->ridiculous++; 3435 } 3436 } 3437 } 3438 } 3439 } 3440 } 3441 } 3442} 3443 3444#define RB_printf printf 3445 3446void 3447output_row(FILE *fd, char *title, int *row){ 3448 register int i; 3449 RB_printf("%s", title); 3450 for(i = 0; i < 10; i++) RB_printf(": %4d", row[i]); 3451 RB_printf("\n"); 3452} 3453 3454int 3455sum_row(int *row) { 3456 int sum = 0; 3457 int i; 3458 for (i = 0; i < 10; i++) sum += row[i]; 3459 return(sum); 3460} 3461 3462void 3463HIST_report(HIST h){ 3464#ifndef OLD_HISTOGRAM 3465 output_row(stdout, "UNIT_USEC ", h->unit_usec); 3466 output_row(stdout, "TEN_USEC ", h->ten_usec); 3467 output_row(stdout, "HUNDRED_USEC ", h->hundred_usec); 3468#else 3469 h->hundred_usec[0] += sum_row(h->unit_usec); 3470 h->hundred_usec[0] += sum_row(h->ten_usec); 3471 output_row(stdout, "TENTH_MSEC ", h->hundred_usec); 3472#endif 3473 output_row(stdout, "UNIT_MSEC ", h->unit_msec); 3474 output_row(stdout, "TEN_MSEC ", h->ten_msec); 3475 output_row(stdout, "HUNDRED_MSEC ", h->hundred_msec); 3476 output_row(stdout, "UNIT_SEC ", h->unit_sec); 3477 output_row(stdout, "TEN_SEC ", h->ten_sec); 3478 RB_printf(">100_SECS: %d\n", h->ridiculous); 3479 RB_printf("HIST_TOTAL: %d\n", h->total); 3480} 3481 3482#endif 3483 3484/* with the advent of sit-and-spin intervals support, we might as well 3485 make these things available all the time, not just for demo or 3486 histogram modes. raj 2006-02-06 */ 3487#ifdef HAVE_GETHRTIME 3488 3489void 3490HIST_timestamp(hrtime_t *timestamp) 3491{ 3492 *timestamp = gethrtime(); 3493} 3494 3495int 3496delta_micro(hrtime_t *begin, hrtime_t *end) 3497{ 3498 long nsecs; 3499 nsecs = (*end) - (*begin); 3500 return(nsecs/1000); 3501} 3502 3503#elif defined(HAVE_GET_HRT) 3504#include "hrt.h" 3505 3506void 3507HIST_timestamp(hrt_t *timestamp) 3508{ 3509 *timestamp = get_hrt(); 3510} 3511 3512int 3513delta_micro(hrt_t *begin, hrt_t *end) 3514{ 3515 3516 return((int)get_hrt_delta(*end,*begin)); 3517 3518} 3519#elif defined(WIN32) 3520void HIST_timestamp(LARGE_INTEGER *timestamp) 3521{ 3522 QueryPerformanceCounter(timestamp); 3523} 3524 3525int delta_micro(LARGE_INTEGER *begin, LARGE_INTEGER *end) 3526{ 3527 LARGE_INTEGER DeltaTimestamp; 3528 static LARGE_INTEGER TickHz = {0,0}; 3529 3530 if (TickHz.QuadPart == 0) 3531 { 3532 QueryPerformanceFrequency(&TickHz); 3533 } 3534 3535 /*+*+ Rick; this will overflow after ~2000 seconds, is that 3536 good enough? Spencer: Yes, that should be more than good 3537 enough for histogram support */ 3538 3539 DeltaTimestamp.QuadPart = (end->QuadPart - begin->QuadPart) * 3540 1000000/TickHz.QuadPart; 3541 assert((DeltaTimestamp.HighPart == 0) && 3542 ((int)DeltaTimestamp.LowPart >= 0)); 3543 3544 return (int)DeltaTimestamp.LowPart; 3545} 3546 3547#else 3548 3549void 3550HIST_timestamp(struct timeval *timestamp) 3551{ 3552 gettimeofday(timestamp,NULL); 3553} 3554 3555 /* return the difference (in micro seconds) between two timeval */ 3556 /* timestamps */ 3557int 3558delta_micro(struct timeval *begin,struct timeval *end) 3559 3560{ 3561 3562 int usecs, secs; 3563 3564 if (end->tv_usec < begin->tv_usec) { 3565 /* borrow a second from the tv_sec */ 3566 end->tv_usec += 1000000; 3567 end->tv_sec--; 3568 } 3569 usecs = end->tv_usec - begin->tv_usec; 3570 secs = end->tv_sec - begin->tv_sec; 3571 3572 usecs += (secs * 1000000); 3573 3574 return(usecs); 3575 3576} 3577#endif /* HAVE_GETHRTIME */ 3578 3579 3580#ifdef WANT_DLPI 3581 3582int 3583put_control(fd, len, pri, ack) 3584 int fd, len, pri, ack; 3585{ 3586 int error; 3587 int flags = 0; 3588 dl_error_ack_t *err_ack = (dl_error_ack_t *)control_data; 3589 3590 control_message.len = len; 3591 3592 if ((error = putmsg(fd, &control_message, 0, pri)) < 0 ) { 3593 fprintf(where,"put_control: putmsg error %d\n",error); 3594 fflush(where); 3595 return(-1); 3596 } 3597 if ((error = getmsg(fd, &control_message, 0, &flags)) < 0) { 3598 fprintf(where,"put_control: getsmg error %d\n",error); 3599 fflush(where); 3600 return(-1); 3601 } 3602 if (err_ack->dl_primitive != ack) { 3603 fprintf(where,"put_control: acknowledgement error wanted %u got %u \n", 3604 ack,err_ack->dl_primitive); 3605 if (err_ack->dl_primitive == DL_ERROR_ACK) { 3606 fprintf(where," dl_error_primitive: %u\n", 3607 err_ack->dl_error_primitive); 3608 fprintf(where," dl_errno: %u\n", 3609 err_ack->dl_errno); 3610 fprintf(where," dl_unix_errno %u\n", 3611 err_ack->dl_unix_errno); 3612 } 3613 fflush(where); 3614 return(-1); 3615 } 3616 3617 return(0); 3618} 3619 3620int 3621dl_open(char devfile[], int ppa) 3622{ 3623 int fd; 3624 dl_attach_req_t *attach_req = (dl_attach_req_t *)control_data; 3625 3626 if ((fd = open(devfile, O_RDWR)) == -1) { 3627 fprintf(where,"netperf: dl_open: open of %s failed, errno = %d\n", 3628 devfile, 3629 errno); 3630 return(-1); 3631 } 3632 3633 attach_req->dl_primitive = DL_ATTACH_REQ; 3634 attach_req->dl_ppa = ppa; 3635 3636 if (put_control(fd, sizeof(dl_attach_req_t), 0, DL_OK_ACK) < 0) { 3637 fprintf(where, 3638 "netperf: dl_open: could not send control message, errno = %d\n", 3639 errno); 3640 return(-1); 3641 } 3642 return(fd); 3643} 3644 3645int 3646dl_bind(int fd, int sap, int mode, char *dlsap_ptr, int *dlsap_len) 3647{ 3648 dl_bind_req_t *bind_req = (dl_bind_req_t *)control_data; 3649 dl_bind_ack_t *bind_ack = (dl_bind_ack_t *)control_data; 3650 3651 bind_req->dl_primitive = DL_BIND_REQ; 3652 bind_req->dl_sap = sap; 3653 bind_req->dl_max_conind = 1; 3654 bind_req->dl_service_mode = mode; 3655 bind_req->dl_conn_mgmt = 0; 3656 bind_req->dl_xidtest_flg = 0; 3657 3658 if (put_control(fd, sizeof(dl_bind_req_t), 0, DL_BIND_ACK) < 0) { 3659 fprintf(where, 3660 "netperf: dl_bind: could not send control message, errno = %d\n", 3661 errno); 3662 return(-1); 3663 } 3664 3665 /* at this point, the control_data portion of the control message */ 3666 /* structure should contain a DL_BIND_ACK, which will have a full */ 3667 /* DLSAP in it. we want to extract this and pass it up so that */ 3668 /* it can be passed around. */ 3669 if (*dlsap_len >= bind_ack->dl_addr_length) { 3670 bcopy((char *)bind_ack+bind_ack->dl_addr_offset, 3671 dlsap_ptr, 3672 bind_ack->dl_addr_length); 3673 *dlsap_len = bind_ack->dl_addr_length; 3674 return(0); 3675 } 3676 else { 3677 return (-1); 3678 } 3679} 3680 3681int 3682dl_connect(int fd, unsigned char *remote_addr, int remote_addr_len) 3683{ 3684 dl_connect_req_t *connection_req = (dl_connect_req_t *)control_data; 3685 dl_connect_con_t *connection_con = (dl_connect_con_t *)control_data; 3686 struct pollfd pinfo; 3687 3688 int flags = 0; 3689 3690 /* this is here on the off chance that we really want some data */ 3691 u_long data_area[512]; 3692 struct strbuf data_message; 3693 3694 int error; 3695 3696 data_message.maxlen = 2048; 3697 data_message.len = 0; 3698 data_message.buf = (char *)data_area; 3699 3700 connection_req->dl_primitive = DL_CONNECT_REQ; 3701 connection_req->dl_dest_addr_length = remote_addr_len; 3702 connection_req->dl_dest_addr_offset = sizeof(dl_connect_req_t); 3703 connection_req->dl_qos_length = 0; 3704 connection_req->dl_qos_offset = 0; 3705 bcopy (remote_addr, 3706 (unsigned char *)control_data + sizeof(dl_connect_req_t), 3707 remote_addr_len); 3708 3709 /* well, I would call the put_control routine here, but the sequence */ 3710 /* of connection stuff with DLPI is a bit screwey with all this */ 3711 /* message passing - Toto, I don't think were in Berkeley anymore. */ 3712 3713 control_message.len = sizeof(dl_connect_req_t) + remote_addr_len; 3714 if ((error = putmsg(fd,&control_message,0,0)) !=0) { 3715 fprintf(where,"dl_connect: putmsg failure, errno = %d, error 0x%x \n", 3716 errno,error); 3717 fflush(where); 3718 return(-1); 3719 }; 3720 3721 pinfo.fd = fd; 3722 pinfo.events = POLLIN | POLLPRI; 3723 pinfo.revents = 0; 3724 3725 if ((error = getmsg(fd,&control_message,&data_message,&flags)) != 0) { 3726 fprintf(where,"dl_connect: getmsg failure, errno = %d, error 0x%x \n", 3727 errno,error); 3728 fflush(where); 3729 return(-1); 3730 } 3731 while (control_data[0] == DL_TEST_CON) { 3732 /* i suppose we spin until we get an error, or a connection */ 3733 /* indication */ 3734 if((error = getmsg(fd,&control_message,&data_message,&flags)) !=0) { 3735 fprintf(where,"dl_connect: getmsg failure, errno = %d, error = 0x%x\n", 3736 errno,error); 3737 fflush(where); 3738 return(-1); 3739 } 3740 } 3741 3742 /* we are out - it either worked or it didn't - which was it? */ 3743 if (control_data[0] == DL_CONNECT_CON) { 3744 return(0); 3745 } 3746 else { 3747 return(-1); 3748 } 3749} 3750 3751int 3752dl_accept(fd, remote_addr, remote_addr_len) 3753 int fd; 3754 unsigned char *remote_addr; 3755 int remote_addr_len; 3756{ 3757 dl_connect_ind_t *connect_ind = (dl_connect_ind_t *)control_data; 3758 dl_connect_res_t *connect_res = (dl_connect_res_t *)control_data; 3759 int tmp_cor; 3760 int flags = 0; 3761 3762 /* hang around and wait for a connection request */ 3763 getmsg(fd,&control_message,0,&flags); 3764 while (control_data[0] != DL_CONNECT_IND) { 3765 getmsg(fd,&control_message,0,&flags); 3766 } 3767 3768 /* now respond to the request. at some point, we may want to be sure */ 3769 /* that the connection came from the correct station address, but */ 3770 /* will assume that we do not have to worry about it just now. */ 3771 3772 tmp_cor = connect_ind->dl_correlation; 3773 3774 connect_res->dl_primitive = DL_CONNECT_RES; 3775 connect_res->dl_correlation = tmp_cor; 3776 connect_res->dl_resp_token = 0; 3777 connect_res->dl_qos_length = 0; 3778 connect_res->dl_qos_offset = 0; 3779 connect_res->dl_growth = 0; 3780 3781 return(put_control(fd, sizeof(dl_connect_res_t), 0, DL_OK_ACK)); 3782 3783} 3784 3785int 3786dl_set_window(fd, window) 3787 int fd, window; 3788{ 3789 return(0); 3790} 3791 3792void 3793dl_stats(fd) 3794 int fd; 3795{ 3796} 3797 3798int 3799dl_send_disc(fd) 3800 int fd; 3801{ 3802} 3803 3804int 3805dl_recv_disc(fd) 3806 int fd; 3807{ 3808} 3809#endif /* WANT_DLPI*/ 3810 3811 /* these routines for confidence intervals are courtesy of IBM. They */ 3812 /* have been modified slightly for more general usage beyond TCP/UDP */ 3813 /* tests. raj 11/94 I would suspect that this code carries an IBM */ 3814 /* copyright that is much the same as that for the original HP */ 3815 /* netperf code */ 3816int confidence_iterations; /* for iterations */ 3817 3818double 3819 result_confid=-10.0, 3820 loc_cpu_confid=-10.0, 3821 rem_cpu_confid=-10.0, 3822 3823 measured_sum_result=0.0, 3824 measured_square_sum_result=0.0, 3825 measured_mean_result=0.0, 3826 measured_var_result=0.0, 3827 3828 measured_sum_local_cpu=0.0, 3829 measured_square_sum_local_cpu=0.0, 3830 measured_mean_local_cpu=0.0, 3831 measured_var_local_cpu=0.0, 3832 3833 measured_sum_remote_cpu=0.0, 3834 measured_square_sum_remote_cpu=0.0, 3835 measured_mean_remote_cpu=0.0, 3836 measured_var_remote_cpu=0.0, 3837 3838 measured_sum_local_service_demand=0.0, 3839 measured_square_sum_local_service_demand=0.0, 3840 measured_mean_local_service_demand=0.0, 3841 measured_var_local_service_demand=0.0, 3842 3843 measured_sum_remote_service_demand=0.0, 3844 measured_square_sum_remote_service_demand=0.0, 3845 measured_mean_remote_service_demand=0.0, 3846 measured_var_remote_service_demand=0.0, 3847 3848 measured_sum_local_time=0.0, 3849 measured_square_sum_local_time=0.0, 3850 measured_mean_local_time=0.0, 3851 measured_var_local_time=0.0, 3852 3853 measured_mean_remote_time=0.0, 3854 3855 measured_fails, 3856 measured_local_results, 3857 confidence=-10.0; 3858/* interval=0.1; */ 3859 3860/************************************************************************/ 3861/* */ 3862/* Constants for Confidence Intervals */ 3863/* */ 3864/************************************************************************/ 3865void 3866init_stat() 3867{ 3868 measured_sum_result=0.0; 3869 measured_square_sum_result=0.0; 3870 measured_mean_result=0.0; 3871 measured_var_result=0.0; 3872 3873 measured_sum_local_cpu=0.0; 3874 measured_square_sum_local_cpu=0.0; 3875 measured_mean_local_cpu=0.0; 3876 measured_var_local_cpu=0.0; 3877 3878 measured_sum_remote_cpu=0.0; 3879 measured_square_sum_remote_cpu=0.0; 3880 measured_mean_remote_cpu=0.0; 3881 measured_var_remote_cpu=0.0; 3882 3883 measured_sum_local_service_demand=0.0; 3884 measured_square_sum_local_service_demand=0.0; 3885 measured_mean_local_service_demand=0.0; 3886 measured_var_local_service_demand=0.0; 3887 3888 measured_sum_remote_service_demand=0.0; 3889 measured_square_sum_remote_service_demand=0.0; 3890 measured_mean_remote_service_demand=0.0; 3891 measured_var_remote_service_demand=0.0; 3892 3893 measured_sum_local_time=0.0; 3894 measured_square_sum_local_time=0.0; 3895 measured_mean_local_time=0.0; 3896 measured_var_local_time=0.0; 3897 3898 measured_mean_remote_time=0.0; 3899 3900 measured_fails = 0.0; 3901 measured_local_results=0.0, 3902 confidence=-10.0; 3903} 3904 3905 /* this routine does a simple table lookup for some statistical */ 3906 /* function that I would remember if I stayed awake in my probstats */ 3907 /* class... raj 11/94 */ 3908double 3909confid(int level, int freedom) 3910{ 3911double t99[35],t95[35]; 3912 3913 t95[1]=12.706; 3914 t95[2]= 4.303; 3915 t95[3]= 3.182; 3916 t95[4]= 2.776; 3917 t95[5]= 2.571; 3918 t95[6]= 2.447; 3919 t95[7]= 2.365; 3920 t95[8]= 2.306; 3921 t95[9]= 2.262; 3922 t95[10]= 2.228; 3923 t95[11]= 2.201; 3924 t95[12]= 2.179; 3925 t95[13]= 2.160; 3926 t95[14]= 2.145; 3927 t95[15]= 2.131; 3928 t95[16]= 2.120; 3929 t95[17]= 2.110; 3930 t95[18]= 2.101; 3931 t95[19]= 2.093; 3932 t95[20]= 2.086; 3933 t95[21]= 2.080; 3934 t95[22]= 2.074; 3935 t95[23]= 2.069; 3936 t95[24]= 2.064; 3937 t95[25]= 2.060; 3938 t95[26]= 2.056; 3939 t95[27]= 2.052; 3940 t95[28]= 2.048; 3941 t95[29]= 2.045; 3942 t95[30]= 2.042; 3943 3944 t99[1]=63.657; 3945 t99[2]= 9.925; 3946 t99[3]= 5.841; 3947 t99[4]= 4.604; 3948 t99[5]= 4.032; 3949 t99[6]= 3.707; 3950 t99[7]= 3.499; 3951 t99[8]= 3.355; 3952 t99[9]= 3.250; 3953 t99[10]= 3.169; 3954 t99[11]= 3.106; 3955 t99[12]= 3.055; 3956 t99[13]= 3.012; 3957 t99[14]= 2.977; 3958 t99[15]= 2.947; 3959 t99[16]= 2.921; 3960 t99[17]= 2.898; 3961 t99[18]= 2.878; 3962 t99[19]= 2.861; 3963 t99[20]= 2.845; 3964 t99[21]= 2.831; 3965 t99[22]= 2.819; 3966 t99[23]= 2.807; 3967 t99[24]= 2.797; 3968 t99[25]= 2.787; 3969 t99[26]= 2.779; 3970 t99[27]= 2.771; 3971 t99[28]= 2.763; 3972 t99[29]= 2.756; 3973 t99[30]= 2.750; 3974 3975 if(level==95){ 3976 return(t95[freedom]); 3977 } else if(level==99){ 3978 return(t99[freedom]); 3979 } else{ 3980 return(0); 3981 } 3982} 3983 3984void 3985calculate_confidence(int confidence_iterations, 3986 float time, 3987 double result, 3988 float loc_cpu, 3989 float rem_cpu, 3990 float loc_sd, 3991 float rem_sd) 3992{ 3993 3994 if (debug) { 3995 fprintf(where, 3996 "calculate_confidence: itr %d; time %f; res %f\n", 3997 confidence_iterations, 3998 time, 3999 result); 4000 fprintf(where, 4001 " lcpu %f; rcpu %f\n", 4002 loc_cpu, 4003 rem_cpu); 4004 fprintf(where, 4005 " lsdm %f; rsdm %f\n", 4006 loc_sd, 4007 rem_sd); 4008 fflush(where); 4009 } 4010 4011 /* the test time */ 4012 measured_sum_local_time += 4013 (double) time; 4014 measured_square_sum_local_time += 4015 (double) time*time; 4016 measured_mean_local_time = 4017 (double) measured_sum_local_time/confidence_iterations; 4018 measured_var_local_time = 4019 (double) measured_square_sum_local_time/confidence_iterations 4020 -measured_mean_local_time*measured_mean_local_time; 4021 4022 /* the test result */ 4023 measured_sum_result += 4024 (double) result; 4025 measured_square_sum_result += 4026 (double) result*result; 4027 measured_mean_result = 4028 (double) measured_sum_result/confidence_iterations; 4029 measured_var_result = 4030 (double) measured_square_sum_result/confidence_iterations 4031 -measured_mean_result*measured_mean_result; 4032 4033 /* local cpu utilization */ 4034 measured_sum_local_cpu += 4035 (double) loc_cpu; 4036 measured_square_sum_local_cpu += 4037 (double) loc_cpu*loc_cpu; 4038 measured_mean_local_cpu = 4039 (double) measured_sum_local_cpu/confidence_iterations; 4040 measured_var_local_cpu = 4041 (double) measured_square_sum_local_cpu/confidence_iterations 4042 -measured_mean_local_cpu*measured_mean_local_cpu; 4043 4044 /* remote cpu util */ 4045 measured_sum_remote_cpu += 4046 (double) rem_cpu; 4047 measured_square_sum_remote_cpu+= 4048 (double) rem_cpu*rem_cpu; 4049 measured_mean_remote_cpu = 4050 (double) measured_sum_remote_cpu/confidence_iterations; 4051 measured_var_remote_cpu = 4052 (double) measured_square_sum_remote_cpu/confidence_iterations 4053 -measured_mean_remote_cpu*measured_mean_remote_cpu; 4054 4055 /* local service demand */ 4056 measured_sum_local_service_demand += 4057 (double) loc_sd; 4058 measured_square_sum_local_service_demand+= 4059 (double) loc_sd*loc_sd; 4060 measured_mean_local_service_demand = 4061 (double) measured_sum_local_service_demand/confidence_iterations; 4062 measured_var_local_service_demand = 4063 (double) measured_square_sum_local_service_demand/confidence_iterations 4064 -measured_mean_local_service_demand*measured_mean_local_service_demand; 4065 4066 /* remote service demand */ 4067 measured_sum_remote_service_demand += 4068 (double) rem_sd; 4069 measured_square_sum_remote_service_demand+= 4070 (double) rem_sd*rem_sd; 4071 measured_mean_remote_service_demand = 4072 (double) measured_sum_remote_service_demand/confidence_iterations; 4073 measured_var_remote_service_demand = 4074 (double) measured_square_sum_remote_service_demand/confidence_iterations 4075 -measured_mean_remote_service_demand*measured_mean_remote_service_demand; 4076 4077 if(confidence_iterations>1){ 4078 result_confid= (double) interval - 4079 2.0 * confid(confidence_level,confidence_iterations-1)* 4080 sqrt(measured_var_result/(confidence_iterations-1.0)) / 4081 measured_mean_result; 4082 4083 loc_cpu_confid= (double) interval - 4084 2.0 * confid(confidence_level,confidence_iterations-1)* 4085 sqrt(measured_var_local_cpu/(confidence_iterations-1.0)) / 4086 measured_mean_local_cpu; 4087 4088 rem_cpu_confid= (double) interval - 4089 2.0 * confid(confidence_level,confidence_iterations-1)* 4090 sqrt(measured_var_remote_cpu/(confidence_iterations-1.0)) / 4091 measured_mean_remote_cpu; 4092 4093 if(debug){ 4094 printf("Conf_itvl %2d: results:%4.1f%% loc_cpu:%4.1f%% rem_cpu:%4.1f%%\n", 4095 confidence_iterations, 4096 (interval-result_confid)*100.0, 4097 (interval-loc_cpu_confid)*100.0, 4098 (interval-rem_cpu_confid)*100.0); 4099 } 4100 4101 /* if the user has requested that we only wait for the result to 4102 be confident rather than the result and CPU util(s) then do 4103 so. raj 2007-08-08 */ 4104 if (!result_confidence_only) { 4105 confidence = min(min(result_confid,loc_cpu_confid),rem_cpu_confid); 4106 } 4107 else { 4108 confidence = result_confid; 4109 } 4110 } 4111} 4112 4113 /* here ends the IBM code */ 4114 4115void 4116retrieve_confident_values(float *elapsed_time, 4117 double *thruput, 4118 float *local_cpu_utilization, 4119 float *remote_cpu_utilization, 4120 float *local_service_demand, 4121 float *remote_service_demand) 4122 4123{ 4124 *elapsed_time = (float)measured_mean_local_time; 4125 *thruput = measured_mean_result; 4126 *local_cpu_utilization = (float)measured_mean_local_cpu; 4127 *remote_cpu_utilization = (float)measured_mean_remote_cpu; 4128 *local_service_demand = (float)measured_mean_local_service_demand; 4129 *remote_service_demand = (float)measured_mean_remote_service_demand; 4130} 4131 4132 /* display_confidence() is called when we could not achieve the */ 4133 /* desirec confidence in the results. it will print the achieved */ 4134 /* confidence to "where" raj 11/94 */ 4135void 4136display_confidence() 4137 4138{ 4139 fprintf(where, 4140 "!!! WARNING\n"); 4141 fprintf(where, 4142 "!!! Desired confidence was not achieved within "); 4143 fprintf(where, 4144 "the specified iterations.\n"); 4145 fprintf(where, 4146 "!!! This implies that there was variability in "); 4147 fprintf(where, 4148 "the test environment that\n"); 4149 fprintf(where, 4150 "!!! must be investigated before going further.\n"); 4151 fprintf(where, 4152 "!!! Confidence intervals: Throughput : %4.1f%%\n", 4153 100.0 * (interval - result_confid)); 4154 fprintf(where, 4155 "!!! Local CPU util : %4.1f%%\n", 4156 100.0 * (interval - loc_cpu_confid)); 4157 fprintf(where, 4158 "!!! Remote CPU util : %4.1f%%\n\n", 4159 100.0 * (interval - rem_cpu_confid)); 4160} 4161 4162