home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 8 Other / 08-Other.zip / netper21.zip / netlib.c < prev    next >
C/C++ Source or Header  |  1997-03-20  |  108KB  |  3,830 lines
  1. char    netlib_id[]="\
  2. @(#)netlib.c (c) Copyright 1993, 1994 Hewlett-Packard Company. Version 2.1";
  3.  
  4. /****************************************************************/
  5. /*                                */
  6. /*    netlib.c                        */
  7. /*                                */
  8. /*    the common utility routines available to all...        */
  9. /*                                */
  10. /*    establish_control()    establish the control socket    */
  11. /*    calibrate_local_cpu()    do local cpu calibration    */
  12. /*    calibrate_remote_cpu()    do remote cpu calibration    */
  13. /*    send_request()        send a request to the remote    */
  14. /*    recv_response()        receive a response from remote    */
  15. /*    send_response()        send a response to the remote    */
  16. /*    recv_request()        recv a request from the remote    */
  17. /*    dump_request()        dump request contents        */
  18. /*    dump_response()        dump response contents        */
  19. /*    cpu_start()        start measuring cpu        */
  20. /*    cpu_stop()        stop measuring cpu        */
  21. /*    calc_cpu_util()        calculate the cpu utilization    */
  22. /*    calc_service_demand()    calculate the service demand    */
  23. /*    calc_thruput()        calulate the tput in units    */
  24. /*    calibrate()        really calibrate local cpu    */
  25. /*    identify_local()    print local host information    */
  26. /*    identify_remote()    print remote host information    */
  27. /*    format_number()        format the number (KB, MB,etc)    */
  28. /*    format_units()        return the format in english    */
  29. /*    msec_sleep()        sleep for some msecs        */
  30. /*      start_timer()           start a timer                   */
  31. /*                                */
  32. /*      the routines you get when DO_DLPI is defined...         */
  33. /*                                                              */
  34. /*      dl_open()               open a file descriptor and      */
  35. /*                              attach to the card              */
  36. /*      dl_mtu()                find the MTU of the card        */
  37. /*      dl_bind()               bind the sap do the card        */
  38. /*      dl_connect()            sender's have of connect        */
  39. /*      dl_accpet()             receiver's half of connect      */
  40. /*      dl_set_window()         set the window size             */
  41. /*      dl_stats()              retrieve statistics             */
  42. /*      dl_send_disc()          initiate disconnect (sender)    */
  43. /*      dl_recv_disc()          accept disconnect (receiver)    */
  44. /****************************************************************/
  45.  
  46. /****************************************************************/
  47. /*                                */
  48. /*    Global include files                          */
  49. /*                                       */
  50. /****************************************************************/
  51.  
  52.  /* It would seem that most of the includes being done here from */
  53.  /* "sys/" actually have higher-level wrappers at just /usr/include. */
  54.  /* This is based on a spot-check of a couple systems at my disposal. */
  55.  /* If you have trouble compiling you may want to add "sys/" raj 10/95 */
  56. #include <limits.h>
  57. #include <signal.h>
  58. #include <sys/types.h>
  59. #include <fcntl.h>
  60. #include <stdio.h>
  61. #include <stdlib.h>
  62. #include <math.h>
  63. #include <string.h>
  64.  
  65.  
  66. #ifndef WIN32
  67.  /* at some point, I would like to get rid of all these "sys/" */
  68.  /* includes where appropriate. if you have a system that requires */
  69.  /* them, speak now, or your system may not comile later revisions of */
  70.  /* netperf. raj 1/96 */
  71. #include <unistd.h>
  72. #include <sys/stat.h>
  73. #include <sys/times.h>
  74. #include <sys/time.h>
  75. #include <sys/socket.h>
  76. #include <netinet/in.h>
  77. #include <arpa/inet.h>
  78. #include <netdb.h>
  79. #include <errno.h>
  80. #include <sys/utsname.h>
  81. #include <sys/param.h>
  82.  
  83. #ifdef USE_LOOPER
  84. #include <sys/mman.h>
  85. #endif /* USE_LOOPER */
  86.  
  87. #else /* WIN32 */
  88.  
  89. #ifdef NT_SDK
  90.  /* this is an alternative for CPU util that is being worked-on, but I */
  91.  /* don't have an SDK for it. raj 1/96 */
  92. #include <nt.h>                                            /* robin */
  93. #include <ntrtl.h>                                         /* robin */
  94. #include <nturtl.h>                                        /* robin */
  95. #endif /* NT_SDK */
  96.  
  97. #include <process.h>
  98. #include <time.h>
  99. #include <windows.h>
  100. #include <winsock.h>
  101. #define SIGALRM (14)
  102. #define sleep(x) Sleep((x)*1000)
  103.  
  104. #endif /* WIN32 */
  105.  
  106. #ifdef _AIX
  107. #include <sys/select.h>
  108. #include <sys/sched.h>
  109. #include <sys/pri.h>
  110. #define PRIORITY PRI_LOW
  111. #else/* _AIX */
  112. #ifdef __sgi 
  113. #include <sys/prctl.h>
  114. #include <sys/schedctl.h>
  115. #define PRIORITY NDPLOMIN
  116. #endif /* __sgi */
  117. #endif /* _AIX */
  118.  
  119. #ifdef USE_PSTAT
  120. #include <sys/dk.h>
  121. #include <sys/pstat.h>
  122. #endif /* USE_PSTAT */
  123.  
  124.  /* not all systems seem to have the sysconf for page size. for those */
  125.  /* which do not, we will assume that the page size is 8192 bytes. */
  126.  /* this should be more than enough to be sure that there is no page */
  127.  /* or cache thrashing by looper processes on MP systems. otherwise */
  128.  /* that's really just too bad - such systems should define */
  129.  /* _SC_PAGE_SIZE - raj 4/95 */
  130. #ifndef _SC_PAGE_SIZE
  131. #define NETPERF_PAGE_SIZE 8192
  132. #else
  133. #define NETPERF_PAGE_SIZE sysconf(_SC_PAGE_SIZE)
  134. #endif /* _SC_PAGE_SIZE */
  135.  
  136. #ifdef DO_DLPI
  137. #include <sys/stream.h>
  138. #include <sys/stropts.h>
  139. #include <sys/poll.h>
  140. #ifdef __osf__
  141. #include <sys/dlpihdr.h>
  142. #else /* __osf__ */
  143. #include <sys/dlpi.h>
  144. #ifdef __hpux
  145. #include <sys/dlpi_ext.h>
  146. #endif /* __hpux */
  147. #endif /* __osf__ */
  148. #endif /* DO_DLPI */
  149.  
  150. #ifdef HISTOGRAM
  151. #include "hist.h"
  152. #endif /* HISTOGRAM */
  153. /****************************************************************/
  154. /*                                                              */
  155. /*    Local Include Files                    */
  156. /*                                                              */
  157. /****************************************************************/
  158. #define NETLIB
  159. #include "netlib.h"
  160. #include "netsh.h"
  161.  
  162.  
  163. /****************************************************************/
  164. /*                                       */
  165. /*    Global constants, macros and variables            */
  166. /*                                       */
  167. /****************************************************************/
  168.  
  169. #ifdef WIN32
  170. struct    timezone {
  171.     int     dummy ;
  172.     } ;
  173.  
  174. int     win_kludge_socket = 0;
  175. #endif /* WIN32 */
  176.  
  177. #ifndef LONG_LONG_MAX
  178. #define LONG_LONG_MAX 9223372036854775807LL
  179. #endif /* LONG_LONG_MAX */
  180.  
  181.  /* older versions of netperf knew about the HP kernel IDLE counter. */
  182.  /* this is now obsolete - in favor of either pstat(), times, or a */
  183.  /* process-level looper process. we also now require support for the */
  184.  /* "long" integer type. raj 4/95.  */
  185.  
  186. int 
  187.   lib_num_loc_cpus;    /* the number of cpus in the system */
  188.  
  189. #define PAGES_PER_CHILD 2
  190.  
  191. #ifdef USE_PSTAT
  192. long long
  193.   *lib_idle_address[MAXCPUS], /* addresses of the per-cpu idle counters    */
  194.   lib_start_count[MAXCPUS],  /* idle counter initial value per-cpu      */
  195.   lib_end_count[MAXCPUS];    /* idle counter final value per-cpu    */
  196.  
  197. long long
  198.   *lib_base_pointer;
  199.  
  200. #else 
  201. #ifdef USE_LOOPER
  202.  
  203. long
  204.   *lib_idle_address[MAXCPUS], /* addresses of the per-cpu idle counters    */
  205.   lib_start_count[MAXCPUS],  /* idle counter initial value per-cpu      */
  206.   lib_end_count[MAXCPUS];    /* idle counter final value per-cpu    */
  207.  
  208. long
  209.   *lib_base_pointer;
  210.  
  211. #ifdef WIN32
  212. HANDLE
  213.   lib_idle_pids[MAXCPUS];    /* the pids (ok, handles) of the per-cpu */
  214.                  /* idle loopers */ 
  215. #else
  216. int
  217.   lib_idle_pids[MAXCPUS];    /* the pids of the per-cpu idle loopers */
  218. #endif /* WIN32 */
  219.  
  220. int
  221.   lib_idle_fd;
  222.   
  223. #endif /* USE_LOOPER */
  224. #endif /* USE_PSTAT */  
  225.  
  226. int    lib_use_idle;
  227. int     cpu_method;
  228.  
  229.  /* if there is no IDLE counter in the kernel */
  230. #ifdef USE_PSTAT
  231. struct    pst_dynamic    pst_dynamic_info;
  232. long            cp_time1[PST_MAX_CPUSTATES];
  233. long                    cp_time2[PST_MAX_CPUSTATES];
  234. #else
  235. #ifdef WIN32
  236. #ifdef NT_SDK
  237. LARGE_INTEGER       systime_start;                         /* robin */
  238. LARGE_INTEGER       systime_end;                           /* robin */ 
  239. KERNEL_USER_TIMES   perf_start;                            /* robin */
  240. KERNEL_USER_TIMES   perf_end;                              /* robin */
  241. SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION sysperf_start;    /* robin */
  242. SYSTEM_PROCESSOR_PERFORMANCE_INFORMATION sysperf_end;      /* robin */
  243. #endif /* NT_SDK */
  244. #else
  245. struct    tms        times_data1, 
  246.                         times_data2;
  247. #endif /* WIN32 */
  248. #endif
  249.  
  250. struct    timeval        time1, time2;
  251. struct    timezone    tz;
  252. float    lib_elapsed,
  253.     lib_local_maxrate,
  254.     lib_remote_maxrate,
  255.     lib_local_cpu_util,
  256.     lib_remote_cpu_util;
  257.  
  258. int    *request_array;
  259. int    *response_array;
  260.  
  261. int    netlib_control;
  262.  
  263. int    server_sock;
  264.  
  265. int    tcp_proto_num;
  266.  
  267.  /* in the past, I was overlaying a structure on an array of ints. now */
  268.  /* I am going to have a "real" structure, and point an array of ints */
  269.  /* at it. the real structure will be forced to the same alignment as */
  270.  /* the type "double." this change will mean that pre-2.1 netperfs */
  271.  /* cannot be mixed with 2.1 and later. raj 11/95 */
  272.  
  273. union    netperf_request_struct    netperf_request;
  274. union    netperf_response_struct    netperf_response;
  275.  
  276. FILE    *where;
  277.  
  278. char    libfmt = 'm';
  279.     
  280. #ifdef DO_DLPI
  281. /* some stuff for DLPI control messages */
  282. #define DLPI_DATA_SIZE 2048
  283.  
  284. unsigned long control_data[DLPI_DATA_SIZE];
  285. struct strbuf control_message = {DLPI_DATA_SIZE, 0, (char *)control_data};
  286.  
  287. #endif /* DO_DLPI */
  288.  
  289. int    times_up;
  290.  
  291. #ifdef WIN32
  292.  /* we use a getopt implementation from net.sources */
  293. /*
  294.  * get option letter from argument vector
  295.  */
  296. int
  297.     opterr = 1,        /* should error messages be printed? */
  298.     optind = 1,        /* index into parent argv vector */
  299.     optopt;            /* character checked for validity */
  300. char
  301.     *optarg;        /* argument associated with option */
  302.  
  303. #define EMSG    ""
  304.  
  305. char *progname;            /* may also be defined elsewhere */
  306.  
  307. #endif /* WIN32 */
  308.  
  309. static int measuring_cpu;
  310.  
  311. #ifdef INTERVALS
  312. static unsigned int usec_per_itvl;
  313.  
  314. void
  315. stop_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("clusterperf: cluster_root: setitimer");
  329.     exit(1);
  330.   }
  331.   return;
  332. }
  333. #endif /* INTERVALS */
  334.  
  335.  
  336.  
  337. #ifdef WIN32
  338. static void
  339. error(char *pch)
  340. {
  341.   if (!opterr) {
  342.     return;        /* without printing */
  343.     }
  344.   fprintf(stderr, "%s: %s: %c\n",
  345.       (NULL != progname) ? progname : "getopt", pch, optopt);
  346. }
  347.  
  348. int
  349. getopt(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.  
  402.  
  403. double
  404. ntohd(net_double)
  405.      double net_double;
  406.  
  407. {
  408.   /* we rely on things being nicely packed */
  409.   union {
  410.     double whole_thing;
  411.     unsigned int words[2];
  412.     unsigned char bytes[8];
  413.   } conv_rec;
  414.  
  415.   unsigned char scratch;
  416.   int i;
  417.  
  418.   /* on those systems where ntohl is a no-op, we want to return the */
  419.   /* original value, unchanged */
  420.  
  421.   if (ntohl(1L) == 1L) {
  422.     return(net_double);
  423.   }
  424.  
  425.   conv_rec.whole_thing = net_double;
  426.  
  427.   /* we know that in the message passing routines that ntohl will have */
  428.   /* been called on the 32 bit quantities. we need to put those back */
  429.   /* the way they belong before we swap */
  430.   conv_rec.words[0] = htonl(conv_rec.words[0]);
  431.   conv_rec.words[1] = htonl(conv_rec.words[1]);
  432.   
  433.   /* now swap */
  434.   for (i=0; i<= 3; i++) {
  435.     scratch = conv_rec.bytes[i];
  436.     conv_rec.bytes[i] = conv_rec.bytes[7-i];
  437.     conv_rec.bytes[7-i] = scratch;
  438.   }
  439.   
  440.   return(conv_rec.whole_thing);
  441.   
  442. }
  443. double
  444. htond(host_double)
  445.      double host_double;
  446.  
  447. {
  448.   /* we rely on things being nicely packed */
  449.   union {
  450.     double whole_thing;
  451.     unsigned int words[2];
  452.     unsigned char bytes[8];
  453.   } conv_rec;
  454.  
  455.   unsigned char scratch;
  456.   int i;
  457.  
  458.   /* on those systems where ntohl is a no-op, we want to return the */
  459.   /* original value, unchanged */
  460.  
  461.   if (ntohl(1L) == 1L) {
  462.     return(host_double);
  463.   }
  464.  
  465.   conv_rec.whole_thing = host_double;
  466.  
  467.   /* now swap */
  468.   for (i=0; i<= 3; i++) {
  469.     scratch = conv_rec.bytes[i];
  470.     conv_rec.bytes[i] = conv_rec.bytes[7-i];
  471.     conv_rec.bytes[7-i] = scratch;
  472.   }
  473.   
  474.   /* we know that in the message passing routines htonl will */
  475.   /* be called on the 32 bit quantities. we need to set things up so */
  476.   /* that when this happens, the proper order will go out on the */
  477.   /* network */
  478.   conv_rec.words[0] = htonl(conv_rec.words[0]);
  479.   conv_rec.words[1] = htonl(conv_rec.words[1]);
  480.   
  481.   return(conv_rec.whole_thing);
  482.   
  483. }
  484.  
  485.  
  486. int
  487. get_num_cpus()
  488.  
  489. {
  490.  
  491.   /* on HP-UX, even when we use the looper procs we need the pstat */
  492.   /* call */ 
  493.  
  494.   int temp_cpus;
  495.  
  496. #ifdef __hpux
  497. #include <sys/pstat.h>
  498.  
  499.   struct pst_dynamic psd;
  500.  
  501.   if (pstat_getdynamic((struct pst_dynamic *)&psd, 
  502.                (size_t)sizeof(psd), (size_t)1, 0) != -1) {
  503.     temp_cpus = psd.psd_proc_cnt;
  504.   }
  505.   else {
  506.     temp_cpus = 1;
  507.   }
  508.  
  509. #else
  510.  
  511.   /* we need to know some other ways to do this, or just fall-back on */
  512.   /* a global command line option - raj 4/95 */
  513.   temp_cpus = shell_num_cpus;
  514.  
  515. #endif /*  __hpux */
  516.  
  517.   if (temp_cpus > MAXCPUS) {
  518.     fprintf(where,
  519.         "Sorry, this system has more CPUs (%d) than I can handle (%d).\n",
  520.         temp_cpus,
  521.         MAXCPUS);
  522.     fprintf(where,
  523.         "Please alter MAXCPUS in netlib.h and recompile.\n");
  524.     fflush(where);
  525.     exit(1);
  526.   }
  527.  
  528.   return(temp_cpus);
  529.   
  530. }  
  531.  
  532. #ifdef WIN32
  533. void
  534. gettimeofday( struct timeval *tv , struct timezone *not_used )
  535. {
  536.     SYSTEMTIME    sys_time ;
  537.     GetSystemTime( &sys_time ) ;
  538.  
  539.     tv->tv_sec = (long)time(NULL) ;
  540.     tv->tv_usec = sys_time.wMilliseconds ;
  541. }
  542. #endif /* WIN32 */
  543.  
  544.      
  545.  
  546. /************************************************************************/
  547. /*                                    */
  548. /*    signal catcher                                            */
  549. /*                                    */
  550. /************************************************************************/
  551.  
  552. void
  553. #ifdef __hpux
  554. catcher(sig, code, scp)
  555.      int sig;
  556.      int code;
  557.      struct sigcontext *scp;
  558. #else /* __hpux */
  559. catcher(sig)
  560.      int sig;
  561. #endif /* __hpux */
  562. {
  563.  
  564. #ifdef __hpux
  565.   if (debug > 2) {
  566.     fprintf(where,"caught signal %d ",sig);
  567.     if (scp) {
  568.       fprintf(where,"while in syscall %d\n",
  569.           scp->sc_syscall);
  570.     }
  571.     else {
  572.       fprintf(where,"null scp\n");
  573.     }
  574.     fflush(where);
  575.   }
  576. #endif /* RAJ_DEBUG */
  577.  
  578.   switch(sig) {
  579.     
  580.   case SIGINT:
  581.     fprintf(where,"netperf: caught SIGINT\n");
  582.     fflush(where);
  583.     exit(1);
  584.     break;
  585.   case SIGALRM: 
  586.    if (--test_len_ticks == 0) {
  587.       /* the test is over */
  588.       if (times_up != 0) {
  589.     fprintf(where,"catcher: timer popped with times_up != 0\n");
  590.     fflush(where);
  591.       }
  592.       times_up = 1;
  593. #ifdef INTERVALS
  594.       stop_itimer();
  595. #endif /* INTERVALS */
  596.       break;
  597.     }
  598.     else {
  599. #ifdef INTERVALS
  600. #ifdef __hpux
  601.       /* the test is not over yet and we must have been using the */
  602.       /* interval timer. if we were in SYS_SIGSUSPEND we want to */
  603.       /* re-start the system call. Otherwise, we want to get out of */
  604.       /* the sigsuspend call. I NEED TO KNOW HOW TO DO THIS FOR OTHER */
  605.       /* OPERATING SYSTEMS. If you know how, please let me know. rick */
  606.       /* jones <raj@cup.hp.com> */
  607.       if (scp->sc_syscall != SYS_SIGSUSPEND) {
  608.     if (debug > 2) {
  609.       fprintf(where,
  610.           "catcher: Time to send burst > interval!\n");
  611.       fflush(where);
  612.     }
  613.     scp->sc_syscall_action = SIG_RESTART;
  614.       }
  615. #endif /* __hpux */
  616.       if (demo_mode) {
  617.     /* spit-out what the performance was in units/s. based on our */
  618.     /* knowledge of the interval length we do not need to call */
  619.     /* gettimeofday() raj 2/95 */
  620.     fprintf(where,"%g\n",(units_this_tick * 
  621.                   (double) 1000000 / 
  622.                   (double) usec_per_itvl));
  623.     fflush(where);
  624.     units_this_tick = (double) 0.0;
  625.       }
  626. #else /* INTERVALS */
  627.       fprintf(where,
  628.           "catcher: interval timer running unexpectedly!\n");
  629.       fflush(where);
  630.       times_up = 1;
  631. #endif /* INTERVALS */      
  632.       break;
  633.     }
  634.   }
  635.   return;
  636. }
  637.  
  638.  
  639. void
  640. install_signal_catchers()
  641.  
  642. {
  643.   /* just a simple little routine to catch a bunch of signals */
  644.  
  645. #ifndef WIN32
  646.   struct sigaction action;
  647.   int i;
  648.  
  649.   fprintf(where,"installing catcher for all signals\n");
  650.   fflush(where);
  651.  
  652.   sigemptyset(&(action.sa_mask));
  653.   action.sa_handler = catcher;
  654.  
  655. #ifdef SA_INTERRUPT
  656.   action.sa_flags = SA_INTERRUPT;
  657. #else /* SA_INTERRUPT */
  658.   action.sa_flags = 0;
  659. #endif /* SA_INTERRUPT */
  660.  
  661.  
  662.   for (i = 1; i <= NSIG; i++) {
  663.     if (i != SIGALRM) {
  664.       if (sigaction(SIGALRM,&action,NULL) != 0) {
  665.     fprintf(where,
  666.         "Could not install signal catcher for sig %d, errno %d\n",
  667.         i,
  668.         errno);
  669.     fflush(where);
  670.  
  671.       }
  672.     }
  673.   }
  674. #else
  675.   return;
  676. #endif /* WIN32 */ 
  677. }
  678.  
  679.  
  680. #ifdef WIN32
  681. #define SIGALRM    (14)
  682. void
  683. emulate_alarm( int seconds )
  684. {
  685.  
  686.     Sleep( seconds * 1000 ) ;
  687.  
  688.     times_up = 1;
  689.  
  690.     /* We have yet to find a good way to fully emulate the effects */
  691.     /* of signals and getting EINTR from system calls under */
  692.     /* winsock, so what we do here is close the socket out from */
  693.     /* under the other thread. it is rather kludgy, but should be */
  694.     /* sufficient to get this puppy shipped. the concept can be */
  695.     /* attributed/blamed :) on Robin raj 1/96 */
  696.  
  697.     if (win_kludge_socket != 0) {
  698.       closesocket(win_kludge_socket);
  699.     }
  700. }
  701.  
  702. #endif /* WIN32 */
  703.  
  704. void
  705. start_timer(time)
  706.      int time;
  707. {
  708.  
  709. #ifdef WIN32
  710. struct    sigaction {
  711.     int dummy ;
  712.     } ;
  713. void    emulate_alarm(int) ;
  714.  
  715. long    thread_id ;
  716.  
  717. CreateThread(0,
  718.          0,
  719.          (LPTHREAD_START_ROUTINE)emulate_alarm,
  720.          (LPVOID)time,
  721.          0,
  722.          &thread_id ) ;
  723.  
  724. #else /* not WIN32 */
  725.  
  726. struct sigaction action;
  727.  
  728. if (debug) {
  729.   fprintf(where,"About to start a timer for %d seconds.\n",time);
  730.   fflush(where);
  731. }
  732.  
  733.   action.sa_handler = catcher;
  734.   sigemptyset(&(action.sa_mask));
  735.   sigaddset(&(action.sa_mask),SIGALRM);
  736.  
  737. #ifdef SA_INTERRUPT
  738.   /* on some systems (SunOS 4.blah), system calls are restarted. we do */
  739.   /* not want that */
  740.   action.sa_flags = SA_INTERRUPT;
  741. #else /* SA_INTERRUPT */
  742.   action.sa_flags = 0;
  743. #endif /* SA_INTERRUPT */
  744.  
  745.   if (sigaction(SIGALRM, &action, NULL) < 0) {
  746.     fprintf(where,"start_timer: error installing alarm handler ");
  747.     fprintf(where,"errno %d\n",errno);
  748.     fflush(where);
  749.     exit(1);
  750.   }
  751.  
  752.   /* this is the easy case - just set the timer for so many seconds */ 
  753.   if (alarm(time) != 0) {
  754.     fprintf(where,
  755.         "error starting alarm timer, errno %d\n",
  756.         errno);
  757.     fflush(where);
  758.   }
  759. #endif /* WIN32 */
  760.  
  761.   test_len_ticks = 1;
  762.  
  763. } 
  764.  
  765.  
  766.  /* this routine will disable any running timer */
  767. void
  768. stop_timer()
  769. {
  770. #ifndef WIN32
  771.   alarm(0);
  772. #else
  773.   /* at some point we may need some win32 equivalent */
  774. #endif /* WIN32 */
  775.  
  776. }
  777.  
  778.  
  779. #ifdef INTERVALS
  780.  /* this routine will enable the interval timer and set things up so */
  781.  /* that for a timed test the test will end at the proper time. it */
  782.  /* should detect the presence of POSIX.4 timer_* routines one of */
  783.  /* these days */
  784. void
  785. start_itimer( interval_len_msec )
  786.      unsigned int interval_len_msec;
  787. {
  788.  
  789.   unsigned int ticks_per_itvl;
  790.  
  791.   struct itimerval new_interval;
  792.   struct itimerval old_interval;
  793.  
  794.   /* if -DINTERVALS was used, we will use the ticking of the itimer to */
  795.   /* tell us when the test is over. while the user will be specifying */
  796.   /* some number of milliseconds, we know that the interval timer is */
  797.   /* really in units of 1/HZ. so, to prevent the test from running */
  798.   /* "long" it would be necessary to keep this in mind when calculating */
  799.   /* the number of itimer events */
  800.  
  801.   ticks_per_itvl = ((interval_wate * sysconf(_SC_CLK_TCK) * 1000) / 
  802.             1000000);
  803.  
  804.   if (ticks_per_itvl == 0) ticks_per_itvl = 1;
  805.  
  806.   /* how many usecs in each interval? */
  807.   usec_per_itvl = ticks_per_itvl * (1000000 / sysconf(_SC_CLK_TCK));
  808.  
  809.   /* how many times will the timer pop before the test is over? */
  810.   if (test_time > 0) {
  811.     /* this was a timed test */
  812.     test_len_ticks = (test_time * 1000000) / usec_per_itvl;
  813.   }
  814.   else {
  815.     /* this was not a timed test, use MAXINT */
  816.     test_len_ticks = INT_MAX;
  817.   }
  818.  
  819.   if (debug) {
  820.     fprintf(where,"setting the interval timer to %d sec %d usec ",
  821.         usec_per_itvl / 1000000,
  822.         usec_per_itvl % 1000000);
  823.     fprintf(where,"test len %d ticks\n",
  824.         test_len_ticks);
  825.     fflush(where);
  826.   }
  827.  
  828.   /* if this was not a timed test, then we really aught to enable the */
  829.   /* signal catcher raj 2/95 */
  830.  
  831.   new_interval.it_interval.tv_sec = usec_per_itvl / 1000000;
  832.   new_interval.it_interval.tv_usec = usec_per_itvl % 1000000;  
  833.   new_interval.it_value.tv_sec = usec_per_itvl / 1000000;
  834.   new_interval.it_value.tv_usec = usec_per_itvl % 1000000;  
  835.   if (setitimer(ITIMER_REAL,&new_interval,&old_interval) != 0) {
  836.     /* there was a problem arming the interval timer */ 
  837.     perror("clusterperf: cluster_root: setitimer");
  838.     exit(1);
  839.   }
  840. }
  841. #endif /* INTERVALS */
  842.  
  843. /****************************************************************/
  844. /*                                */
  845. /*    netlib_init()                        */
  846. /*                                */
  847. /*    initialize the performance library...            */
  848. /*                                */
  849. /****************************************************************/
  850.  
  851. void
  852. netlib_init()
  853. {
  854.   where           = stdout;
  855.  
  856.   request_array = (int *)(&netperf_request);
  857.   response_array = (int *)(&netperf_response);
  858.  
  859.   if (debug) {
  860.     fprintf(where,
  861.         "netlib_init: request_array at 0x%x\n",
  862.         request_array);
  863.     fprintf(where,
  864.         "netlib_init: response_array at 0x%x\n",
  865.         response_array);
  866.  
  867.     fflush(where);
  868.   }
  869.  
  870. }
  871.  
  872.  /* this routine will conver the string into an unsigned integer. it */
  873.  /* is used primarily for the command-line options taking a number */
  874.  /* (such as the socket size) which could be rather large. If someone */
  875.  /* enters 32M, then the number will be converted to 32 * 1024 * 1024. */
  876.  /* If they inter 32m, the number will be converted to 32 * 1000 * */
  877.  /* 1000 */
  878. unsigned int
  879. convert(string)
  880.      char *string;
  881.  
  882. {
  883.   unsigned int base;
  884.   base = atoi(string);
  885.   if (strstr(string,"K")) {
  886.     base *= 1024;
  887.   }
  888.   if (strstr(string,"M")) {
  889.     base *= (1024 * 1024);
  890.   }
  891.   if (strstr(string,"G")) {
  892.     base *= (1024 * 1024 * 1024);
  893.   }
  894.   if (strstr(string,"k")) {
  895.     base *= (1000);
  896.   }
  897.   if (strstr(string,"m")) {
  898.     base *= (1000 * 1000);
  899.   }
  900.   if (strstr(string,"g")) {
  901.     base *= (1000 * 1000 * 1000);
  902.   }
  903.   return(base);
  904. }
  905.  
  906.  
  907.  /* this routine will allocate a circular list of buffers for either */
  908.  /* send or receive operations. each of these buffers will be aligned */
  909.  /* and offset as per the users request. the circumference of this */
  910.  /* ring will be controlled by the setting of send_width. the buffers */
  911.  /* will be filled with data from the file specified in fill_file. if */
  912.  /* fill_file is an empty string, the buffers will not be filled with */
  913.  /* any particular data */
  914.  
  915. struct ring_elt *
  916. allocate_buffer_ring(width, buffer_size, alignment, offset)
  917.      int width;
  918.      int buffer_size;
  919.      int alignment;
  920.      int offset;
  921. {
  922.  
  923.   struct ring_elt *first_link = NULL;
  924.   struct ring_elt *temp_link  = NULL;
  925.   struct ring_elt *prev_link;
  926.  
  927.   int i;
  928.   int malloc_size;
  929.   int bytes_left;
  930.   int bytes_read;
  931.   int do_fill;
  932.  
  933.   FILE *fill_source;
  934.  
  935.   malloc_size = buffer_size + alignment + offset;
  936.  
  937.   /* did the user wish to have the buffers pre-filled with data from a */
  938.   /* particular source? */
  939.   if (strcmp(fill_file,"") == 0) {
  940.     do_fill = 0;
  941.     fill_source = NULL;
  942.   }
  943.   else {
  944.     do_fill = 1;
  945.     fill_source = (FILE *)fopen(fill_file,"r");
  946.     if (fill_source == (FILE *)NULL) {
  947.       perror("Could not open requested fill file");
  948.       exit(1);
  949.     }
  950.   }
  951.  
  952.   prev_link = NULL;
  953.   for (i = 1; i <= width; i++) {
  954.     /* get the ring element */
  955.     temp_link = (struct ring_elt *)malloc(sizeof(struct ring_elt));
  956.     /* remember the first one so we can close the ring at the end */
  957.     if (i == 1) {
  958.       first_link = temp_link;
  959.     }
  960.     temp_link->buffer_base = (char *)malloc(malloc_size);
  961.     temp_link->buffer_ptr = (char *)(( (long)(temp_link->buffer_base) + 
  962.               (long)alignment - 1) &    
  963.              ~((long)alignment - 1));
  964.     temp_link->buffer_ptr += offset;
  965.     /* is where the buffer fill code goes. */
  966.     if (do_fill) {
  967.       bytes_left = buffer_size;
  968.       while (bytes_left) {
  969.     if (((bytes_read = fread(temp_link->buffer_ptr,
  970.                  1,
  971.                  bytes_left,
  972.                  fill_source)) == 0) &&
  973.         (feof(fill_source))){
  974.       rewind(fill_source);
  975.     }
  976.     bytes_left -= bytes_read;
  977.       }
  978.     }
  979.     temp_link->next = prev_link;
  980.     prev_link = temp_link;
  981.   }
  982.   first_link->next = temp_link;
  983.  
  984.   return(first_link); /* it's a circle, doesn't matter which we return */
  985. }
  986.  
  987.  /***********************************************************************/
  988.  /*                                    */
  989.  /*    dump_request()                            */
  990.  /*                                    */
  991.  /* display the contents of the request array to the user. it will    */
  992.  /* display the contents in decimal, hex, and ascii, with four bytes    */
  993.  /* per line.                                */
  994.  /*                                    */
  995.  /***********************************************************************/
  996.  
  997. void
  998. dump_request()
  999. {
  1000. int counter = 0;
  1001. fprintf(where,"request contents:\n");
  1002. for (counter = 0; counter < ((sizeof(netperf_request)/4)-3); counter += 4) {
  1003.   fprintf(where,"%d:\t%8x %8x %8x %8x \t|%4.4s| |%4.4s| |%4.4s| |%4.4s|\n",
  1004.       counter,
  1005.       request_array[counter],
  1006.       request_array[counter+1],
  1007.       request_array[counter+2],
  1008.       request_array[counter+3],
  1009.       (char *)&request_array[counter],
  1010.       (char *)&request_array[counter+1],
  1011.       (char *)&request_array[counter+2],
  1012.       (char *)&request_array[counter+3]);
  1013. }
  1014. fflush(where);
  1015. }
  1016.  
  1017.  
  1018.  /***********************************************************************/
  1019.  /*                                    */
  1020.  /*    dump_response()                            */
  1021.  /*                                    */
  1022.  /* display the content of the response array to the user. it will    */
  1023.  /* display the contents in decimal, hex, and ascii, with four bytes    */
  1024.  /* per line.                                */
  1025.  /*                                    */
  1026.  /***********************************************************************/
  1027.  
  1028. void
  1029. dump_response()
  1030. {
  1031. int counter = 0;
  1032.  
  1033. fprintf(where,"response contents\n");
  1034. for (counter = 0; counter < ((sizeof(netperf_response)/4)-3); counter += 4) {
  1035.   fprintf(where,"%d:\t%8x %8x %8x %8x \t>%4.4s< >%4.4s< >%4.4s< >%4.4s<\n",
  1036.       counter,
  1037.       response_array[counter],
  1038.       response_array[counter+1],
  1039.       response_array[counter+2],
  1040.       response_array[counter+3],
  1041.       (char *)&response_array[counter],
  1042.       (char *)&response_array[counter+1],
  1043.       (char *)&response_array[counter+2],
  1044.       (char *)&response_array[counter+3]);
  1045. }
  1046. fflush(where);
  1047. }
  1048.  
  1049.  /***********************************************************************/
  1050.  /*                                    */
  1051.  /*    format_number()                            */
  1052.  /*                                    */
  1053.  /* return a pointer to a formatted string containing the value passed  */
  1054.  /* translated into the units specified. It assumes that the base units */
  1055.  /* are bytes. If the format calls for bits, it will use SI units (10^) */
  1056.  /* if the format calls for bytes, it will use CS units (2^)...        */
  1057.  /* This routine should look familiar to uses of the latest ttcp...    */
  1058.  /*                                    */
  1059.  /***********************************************************************/
  1060.  
  1061. char *
  1062. format_number(number)
  1063. double    number;
  1064. {
  1065.     static    char    fmtbuf[64];
  1066.     
  1067.     switch (libfmt) {
  1068.     case 'K':
  1069.         sprintf(fmtbuf, "%-7.2f" , number / 1024.0);
  1070.         break;
  1071.     case 'M':
  1072.         sprintf(fmtbuf, "%-7.2f", number / 1024.0 / 1024.0);
  1073.         break;
  1074.     case 'G':
  1075.         sprintf(fmtbuf, "%-7.2f", number / 1024.0 / 1024.0 / 1024.0);
  1076.         break;
  1077.     case 'k':
  1078.         sprintf(fmtbuf, "%-7.2f", number * 8 / 1000.0);
  1079.         break;
  1080.     case 'm':
  1081.         sprintf(fmtbuf, "%-7.2f", number * 8 / 1000.0 / 1000.0);
  1082.         break;
  1083.     case 'g':
  1084.         sprintf(fmtbuf, "%-7.2f", number * 8 / 1000.0 / 1000.0 / 1000.0);
  1085.         break;
  1086.  
  1087.         default:
  1088.         sprintf(fmtbuf, "%-7.2f", number / 1024.0);
  1089.     }
  1090.  
  1091.     return fmtbuf;
  1092. }
  1093.  
  1094. char
  1095. format_cpu_method(method)
  1096.      int method;
  1097. {
  1098.  
  1099.   char method_char;
  1100.  
  1101.   switch (method) {
  1102.   case CPU_UNKNOWN:
  1103.     method_char = 'U';
  1104.     break;
  1105.   case HP_IDLE_COUNTER:
  1106.     method_char = 'I';
  1107.     break;
  1108.   case PSTAT:
  1109.     method_char = 'P';
  1110.     break;
  1111.   case TIMES:
  1112.     method_char = 'T';
  1113.     break;
  1114.   case GETRUSAGE:
  1115.     method_char = 'R';
  1116.     break;
  1117.   case LOOPER:
  1118.     method_char = 'L';
  1119.     break;
  1120.   case NT_METHOD:
  1121.     method_char = 'N';
  1122.     break;
  1123.   default:
  1124.     method_char = '?';
  1125.   }
  1126.   
  1127.   return method_char;
  1128.  
  1129. }
  1130.  
  1131. char *
  1132. format_units()
  1133. {
  1134.   static    char    unitbuf[64];
  1135.   
  1136.   switch (libfmt) {
  1137.   case 'K':
  1138.     sprintf(unitbuf, "%s", "KBytes");
  1139.     break;
  1140.   case 'M':
  1141.     sprintf(unitbuf, "%s", "MBytes");
  1142.     break;
  1143.   case 'G':
  1144.     sprintf(unitbuf, "%s", "GBytes");
  1145.     break;
  1146.   case 'k':
  1147.     sprintf(unitbuf, "%s", "10^3bits");
  1148.     break;
  1149.   case 'm':
  1150.     sprintf(unitbuf, "%s", "10^6bits");
  1151.     break;
  1152.   case 'g':
  1153.     sprintf(unitbuf, "%s", "10^9bits");
  1154.     break;
  1155.     
  1156.   default:
  1157.     sprintf(unitbuf, "%s", "KBytes");
  1158.   }
  1159.   
  1160.   return unitbuf;
  1161. }
  1162.  
  1163.  
  1164. /****************************************************************/
  1165. /*                                */
  1166. /*    shutdown_control()                    */
  1167. /*                                */
  1168. /* tear-down the control connection between me and the server.  */
  1169. /****************************************************************/
  1170.  
  1171. void 
  1172. shutdown_control()
  1173. {
  1174.  
  1175.   char     *buf = (char *)&netperf_response;
  1176.   int     buflen = sizeof(netperf_response);
  1177.  
  1178.   /* stuff for select, use fd_set for better compliance */
  1179.   fd_set    readfds;
  1180.   struct    timeval    timeout;
  1181.  
  1182.   if (debug) {
  1183.     fprintf(where,
  1184.         "shutdown_control: shutdown of control connection requested.\n");
  1185.     fflush(where);
  1186.   }
  1187.  
  1188.   /* first, we say that we will be sending no more data on the */
  1189.   /* connection */
  1190.   if (shutdown(netlib_control,1) == -1) {
  1191.     fprintf(where,
  1192.         "shutdown_control: error in shutdown. errno %d\n",
  1193.         errno);
  1194.     fflush(where);
  1195.     exit(1);
  1196.   }
  1197.  
  1198.   /* Now, we hang on a select waiting for the socket to become */
  1199.   /* readable to receive the shutdown indication from the remote. this */
  1200.   /* will be "just" like the recv_response() code */
  1201.  
  1202.   /* we only select once. it is assumed that if the response is split */
  1203.   /* (which should not be happening, that we will receive the whole */
  1204.   /* thing and not have a problem ;-) */
  1205.  
  1206.   FD_ZERO(&readfds);
  1207.   FD_SET(netlib_control,&readfds);
  1208.   timeout.tv_sec  = 60; /* wait two minutes then punt */
  1209.   timeout.tv_usec = 0;
  1210.  
  1211.   /* select had better return one, or there was either a problem or a */
  1212.   /* timeout... */
  1213.   if (select(FD_SETSIZE,
  1214.          &readfds,
  1215.          0,
  1216.          0,
  1217.          &timeout) != 1) {
  1218.     fprintf(where,
  1219.         "shutdown_control: no response received. errno %d\n",
  1220.         errno);
  1221.     fflush(where);
  1222.     exit(1);
  1223.   }
  1224.  
  1225.   /* we now assume that the socket has come ready for reading */
  1226.   recv(netlib_control, buf, buflen,0);
  1227.  
  1228. }
  1229.  
  1230.  
  1231.  /***********************************************************************/
  1232.  /*                                    */
  1233.  /*    send_request()                            */
  1234.  /*                                    */
  1235.  /* send a netperf request on the control socket to the remote half of     */
  1236.  /* the connection. to get us closer to intervendor interoperability,     */
  1237.  /* we will call htonl on each of the int that compose the message to     */
  1238.  /* be sent. the server-half of the connection will call the ntohl     */
  1239.  /* routine to undo any changes that may have been made...         */
  1240.  /*                                     */
  1241.  /***********************************************************************/
  1242.  
  1243. void
  1244. send_request()
  1245. {
  1246.   int    counter=0;
  1247.   
  1248.   /* display the contents of the request if the debug level is high */
  1249.   /* enough. otherwise, just send the darned thing ;-) */
  1250.   
  1251.   if (debug > 1) {
  1252.     fprintf(where,"entered send_request...contents before htonl:\n");
  1253.     dump_request();
  1254.   }
  1255.   
  1256.   /* put the entire request array into network order. We do this */
  1257.   /* arbitrarily rather than trying to figure-out just how much */
  1258.   /* of the request array contains real information. this should */
  1259.   /* be simpler, and at any rate, the performance of sending */
  1260.   /* control messages for this benchmark is not of any real */
  1261.   /* concern. */ 
  1262.   
  1263.   for (counter=0;counter < sizeof(netperf_request)/4; counter++) {
  1264.     request_array[counter] = htonl(request_array[counter]);
  1265.   }
  1266.   
  1267.   if (debug > 1) {
  1268.     fprintf(where,"send_request...contents after htonl:\n");
  1269.     dump_request();
  1270.  
  1271.     fprintf(where,
  1272.         "\nsend_request: about to send %d bytes from %x\n",
  1273.         sizeof(netperf_request),
  1274.         &netperf_request);
  1275.     fflush(where);
  1276.   }
  1277.  
  1278.   if (send(netlib_control,
  1279.        (char *)&netperf_request,
  1280.        sizeof(netperf_request),
  1281.        0) != sizeof(netperf_request)) {
  1282.     perror("send_request: send call failure");
  1283.     
  1284.     exit(1);
  1285.   }
  1286. }
  1287.  
  1288. /***********************************************************************/
  1289.  /*                                    */
  1290.  /*    send_response()                            */
  1291.  /*                                    */
  1292.  /* send a netperf response on the control socket to the remote half of */
  1293.  /* the connection. to get us closer to intervendor interoperability,     */
  1294.  /* we will call htonl on each of the int that compose the message to     */
  1295.  /* be sent. the other half of the connection will call the ntohl     */
  1296.  /* routine to undo any changes that may have been made...         */
  1297.  /*                                     */
  1298.  /***********************************************************************/
  1299.  
  1300. void
  1301. send_response()
  1302. {
  1303.   int    counter=0;
  1304.  
  1305.   /* display the contents of the request if the debug level is high */
  1306.   /* enough. otherwise, just send the darned thing ;-) */
  1307.  
  1308.   if (debug > 1) {
  1309.     fprintf(where,
  1310.         "send_response: contents of %d ints before htonl\n",
  1311.         sizeof(netperf_response)/4);
  1312.     dump_response();
  1313.   }
  1314.  
  1315.   /* put the entire response_array into network order. We do this */
  1316.   /* arbitrarily rather than trying to figure-out just how much of the */
  1317.   /* request array contains real information. this should be simpler, */
  1318.   /* and at any rate, the performance of sending control messages for */
  1319.   /* this benchmark is not of any real concern. */
  1320.   
  1321.   for (counter=0;counter < sizeof(netperf_response)/4; counter++) {
  1322.     response_array[counter] = htonl(response_array[counter]);
  1323.   }
  1324.   
  1325.   if (debug > 1) {
  1326.     fprintf(where,
  1327.         "send_response: contents after htonl\n");
  1328.     dump_response();
  1329.     fprintf(where,
  1330.         "about to send %d bytes from %x\n",
  1331.         sizeof(netperf_response),
  1332.         &netperf_response);
  1333.     fflush(where);
  1334.   }
  1335.  
  1336.   /*KC*/
  1337.   if (send(server_sock,
  1338.        (char *)&netperf_response,
  1339.        sizeof(netperf_response),
  1340.        0) != sizeof(netperf_response)) {
  1341.     perror("send_response: send call failure");
  1342.     exit(1);
  1343.   }
  1344.   
  1345. }
  1346.  
  1347.  /***********************************************************************/
  1348.  /*                                     */
  1349.  /*    recv_request()                            */
  1350.  /*                                    */
  1351.  /* receive the remote's request on the control socket. we will put    */
  1352.  /* the entire response into host order before giving it to the        */
  1353.  /* calling routine. hopefully, this will go most of the way to        */
  1354.  /* insuring intervendor interoperability. if there are any problems,    */
  1355.  /* we will just punt the entire situation.                */
  1356.  /*                                    */
  1357.  /***********************************************************************/
  1358.  
  1359. void
  1360. recv_request()
  1361. {
  1362. int     tot_bytes_recvd,
  1363.         bytes_recvd, 
  1364.         bytes_left;
  1365. char     *buf = (char *)&netperf_request;
  1366. int    buflen = sizeof(netperf_request);
  1367. int    counter;
  1368.  
  1369. tot_bytes_recvd = 0;    
  1370. bytes_left      = buflen;
  1371. while ((tot_bytes_recvd != buflen) &&
  1372.        ((bytes_recvd = recv(server_sock, buf, bytes_left,0)) > 0 )) {
  1373.   tot_bytes_recvd += bytes_recvd;
  1374.   buf             += bytes_recvd;
  1375.   bytes_left      -= bytes_recvd;
  1376. }
  1377.  
  1378. /* put the request into host order */
  1379.  
  1380. for (counter = 0; counter < sizeof(netperf_request)/sizeof(int); counter++) {
  1381.   request_array[counter] = ntohl(request_array[counter]);
  1382. }
  1383.  
  1384. if (debug) {
  1385.   fprintf(where,
  1386.       "recv_request: received %d bytes of request.\n",
  1387.       tot_bytes_recvd);
  1388.   fflush(where);
  1389. }
  1390.  
  1391. #ifdef WIN32
  1392. if (bytes_recvd == SOCKET_ERROR ) {
  1393. #else
  1394. if (bytes_recvd == -1) {
  1395. #endif /* WIN32 */
  1396.   fprintf(where,
  1397.       "recv_request: error on recv, errno %d\n",
  1398.       errno);
  1399.   fflush(where);
  1400.   exit(1);
  1401. }
  1402.  
  1403. if (bytes_recvd == 0) {
  1404.   /* the remote has shutdown the control connection, we should shut it */
  1405.   /* down as well and exit */
  1406.  
  1407.   if (debug) {
  1408.     fprintf(where,
  1409.         "recv_request: remote reqeusted shutdown of control\n");
  1410.     fflush(where);
  1411.   }
  1412.  
  1413.   shutdown_control();
  1414.   exit(0);
  1415. }
  1416.  
  1417. if (tot_bytes_recvd < buflen) {
  1418.   if (debug > 1)
  1419.     dump_request();
  1420.  
  1421.   fprintf(where,
  1422.       "recv_request: partial request received of %d bytes\n",
  1423.       tot_bytes_recvd);
  1424.   fflush(where);
  1425.   exit(1);
  1426. }
  1427.  
  1428. if (debug > 1) {
  1429.   dump_request();
  1430. }
  1431. }
  1432.  
  1433.  /***********************************************************************/
  1434.  /*                                     */
  1435.  /*    recv_response()                            */
  1436.  /*                                    */
  1437.  /* receive the remote's response on the control socket. we will put    */
  1438.  /* the entire response into host order before giving it to the        */
  1439.  /* calling routine. hopefully, this will go most of the way to        */
  1440.  /* insuring intervendor interoperability. if there are any problems,    */
  1441.  /* we will just punt the entire situation.                */
  1442.  /*                                    */
  1443.  /* The call to select at the beginning is to get us out of hang    */
  1444.  /* situations where the remote gives-up but we don't find-out about    */
  1445.  /* it. This seems to happen only rarely, but it would be nice to be    */
  1446.  /* somewhat robust ;-)                            */
  1447.  /***********************************************************************/
  1448.  
  1449. void
  1450. recv_response()
  1451. {
  1452. int     tot_bytes_recvd,
  1453.         bytes_recvd = 0, 
  1454.         bytes_left;
  1455. char     *buf = (char *)&netperf_response;
  1456. int     buflen = sizeof(netperf_response);
  1457. int    counter;
  1458.  
  1459.  /* stuff for select, use fd_set for better compliance */
  1460. fd_set    readfds;
  1461. struct    timeval    timeout;
  1462.  
  1463. tot_bytes_recvd = 0;    
  1464. bytes_left      = buflen;
  1465.  
  1466. /* zero out the response structure */
  1467.  
  1468. /* BUG FIX SJB 2/4/93 - should be < not <= */
  1469. for (counter = 0; counter < sizeof(netperf_response)/sizeof(int); counter++) {
  1470.         response_array[counter] = 0;
  1471. }
  1472.  
  1473.  /* we only select once. it is assumed that if the response is split */
  1474.  /* (which should not be happening, that we will receive the whole */
  1475.  /* thing and not have a problem ;-) */
  1476.  
  1477. FD_ZERO(&readfds);
  1478. FD_SET(netlib_control,&readfds);
  1479. timeout.tv_sec  = 60; /* wait one minute then punt */
  1480. timeout.tv_usec = 0;
  1481.  
  1482.  /* select had better return one, or there was either a problem or a */
  1483.  /* timeout... */
  1484.  
  1485. if ((counter = select(FD_SETSIZE,
  1486.               &readfds,
  1487.               0,
  1488.               0,
  1489.               &timeout)) != 1) {
  1490.   fprintf(where,
  1491.       "netperf: receive_response: no response received. errno %d counter %d\n",
  1492.       errno,
  1493.       counter);
  1494.   exit(1);
  1495. }
  1496.  
  1497. while ((tot_bytes_recvd != buflen) &&
  1498.        ((bytes_recvd = recv(netlib_control, buf, bytes_left,0)) > 0 )) {
  1499.   tot_bytes_recvd += bytes_recvd;
  1500.   buf             += bytes_recvd;
  1501.   bytes_left      -= bytes_recvd;
  1502. }
  1503.  
  1504. if (debug) {
  1505.   fprintf(where,"recv_response: received a %d byte response\n",
  1506.       tot_bytes_recvd);
  1507.   fflush(where);
  1508. }
  1509.  
  1510. /* put the response into host order */
  1511.  
  1512. for (counter = 0; counter < sizeof(netperf_response)/sizeof(int); counter++) {
  1513.   response_array[counter] = ntohl(response_array[counter]);
  1514. }
  1515.  
  1516. if (bytes_recvd == -1) {
  1517.     perror("recv_response");
  1518.     exit(1);
  1519. }
  1520. if (tot_bytes_recvd < buflen) {
  1521.   fprintf(stderr,
  1522.       "recv_response: partial response received: %d bytes\n",
  1523.       tot_bytes_recvd);
  1524.   fflush(stderr);
  1525.   if (debug > 1)
  1526.     dump_response();
  1527.   exit(1);
  1528. }
  1529. if (debug > 1) {
  1530.   dump_response();
  1531. }
  1532. }
  1533.  
  1534.  
  1535.  
  1536. #ifdef USE_PSTAT
  1537. int
  1538. hi_32(big_int)
  1539.      long long *big_int;
  1540. {
  1541.   union overlay_u {
  1542.     long long  dword;
  1543.     long       words[2];
  1544.   } *overlay;
  1545.  
  1546.   overlay = (union overlay_u *)big_int;
  1547.   /* on those systems which are byte swapped, we really wish to */
  1548.   /* return words[1] - at least I think so - raj 4/95 */
  1549.   if (htonl(1L) == 1L) {
  1550.     /* we are a "normal" :) machine */
  1551.     return(overlay->words[0]);
  1552.   }
  1553.   else {
  1554.     return(overlay->words[1]);
  1555.   }
  1556. }
  1557.  
  1558. int
  1559. lo_32(big_int)
  1560.      long long *big_int;
  1561. {
  1562.   union overlay_u {
  1563.     long long  dword;
  1564.     long       words[2];
  1565.   } *overlay;
  1566.  
  1567.   overlay = (union overlay_u *)big_int;
  1568.   /* on those systems which are byte swapped, we really wish to */
  1569.   /* return words[0] - at least I think so - raj 4/95 */
  1570.   if (htonl(1L) == 1L) {
  1571.     /* we are a "normal" :) machine */
  1572.     return(overlay->words[1]);
  1573.   }
  1574.   else {
  1575.     return(overlay->words[0]);
  1576.   }
  1577. }
  1578.  
  1579. #endif /* USE_PSTAT */
  1580.  
  1581.  
  1582.  
  1583. #ifdef USE_LOOPER
  1584.  
  1585.  /* calibrate_looper */
  1586.  
  1587.  /* Loop a number of times, sleeping wait_time seconds each and */
  1588.  /* count how high the idle counter gets each time. Return  the */
  1589.  /* measured cpu rate to the calling routine. raj 4/95 */
  1590.  
  1591. float
  1592. calibrate_looper(times,wait_time)
  1593.      int times;
  1594.      int wait_time;
  1595.  
  1596. {
  1597.  
  1598.   long    
  1599.     firstcnt[MAXCPUS],
  1600.     secondcnt[MAXCPUS];
  1601.  
  1602.   float    
  1603.     elapsed,
  1604.     temp_rate,
  1605.     rate[MAXTIMES],
  1606.     local_maxrate;
  1607.  
  1608.   long    
  1609.     sec,
  1610.     usec;
  1611.  
  1612.   int    
  1613.     i,
  1614.     j;
  1615.   
  1616.   struct  timeval time1, time2 ;
  1617.   struct  timezone tz;
  1618.   
  1619.   if (times > MAXTIMES) {
  1620.     times = MAXTIMES;
  1621.   }
  1622.  
  1623.   local_maxrate = (float)-1.0;
  1624.   
  1625.   for(i = 0; i < times; i++) {
  1626.     rate[i] = (float)0.0;
  1627.     for (j = 0; j < lib_num_loc_cpus; j++) {
  1628.       firstcnt[j] = *(lib_idle_address[j]);
  1629.     }
  1630.     gettimeofday (&time1, &tz);
  1631.     sleep(wait_time);
  1632.     gettimeofday (&time2, &tz);
  1633.  
  1634.     if (time2.tv_usec < time1.tv_usec)
  1635.       {
  1636.     time2.tv_usec += 1000000;
  1637.     time2.tv_sec -=1;
  1638.       }
  1639.     sec = time2.tv_sec - time1.tv_sec;
  1640.     usec = time2.tv_usec - time1.tv_usec;
  1641.     elapsed = (float)sec + ((float)usec/(float)1000000.0);
  1642.     
  1643.     if(debug) {
  1644.       fprintf(where, "Calibration for counter run: %d\n",i);
  1645.       fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec);
  1646.       fprintf(where,"\telapsed time = %g\n",elapsed);
  1647.     }
  1648.  
  1649.     for (j = 0; j < lib_num_loc_cpus; j++) {
  1650.       secondcnt[j] = *(lib_idle_address[j]);
  1651.       if(debug) {
  1652.     /* I know that there are situations where compilers know about */
  1653.     /* long long, but the library fucntions do not... raj 4/95 */
  1654.     fprintf(where,
  1655.         "\tfirstcnt[%d] = 0x%8.8x%8.8x secondcnt[%d] = 0x%8.8x%8.8x\n",
  1656.         j,
  1657.         firstcnt[j],
  1658.         firstcnt[j],
  1659.         j,
  1660.         secondcnt[j],
  1661.         secondcnt[j]);
  1662.       }
  1663.       /* we assume that it would wrap no more than once. we also */
  1664.       /* assume that the result of subtracting will "fit" raj 4/95 */
  1665.       temp_rate = (secondcnt[j] >= firstcnt[j]) ?
  1666.     (float)(secondcnt[j] - firstcnt[j])/elapsed : 
  1667.       (float)(secondcnt[j]-firstcnt[j]+MAXLONG)/elapsed;
  1668.       if (temp_rate > rate[i]) rate[i] = temp_rate;
  1669.       if(debug) {
  1670.     fprintf(where,"\trate[%d] = %g\n",i,rate[i]);
  1671.     fflush(where);
  1672.       }
  1673.       if (local_maxrate < rate[i]) local_maxrate = rate[i];
  1674.     }
  1675.   }
  1676.   if(debug) {
  1677.     fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate);
  1678.     fflush(where);
  1679.   }
  1680.   return local_maxrate;
  1681. }
  1682. #endif /* USE_LOOPER */
  1683.  
  1684.  
  1685. #ifdef USE_PSTAT
  1686. #ifdef PSTAT_IPCINFO
  1687. /****************************************************************/
  1688. /*                                */
  1689. /*    calibrate_pstat                                         */
  1690. /*                                */
  1691. /*    Loop a number of times, sleeping wait_time seconds each */
  1692. /* and count how high the idle counter gets each time. Return    */
  1693. /* the measured cpu rate to the calling routine.        */
  1694. /*                                */
  1695. /****************************************************************/
  1696.  
  1697. float
  1698. calibrate_pstat(times,wait_time)
  1699.      int times;
  1700.      int wait_time;
  1701.  
  1702. {
  1703.   long long
  1704.     firstcnt[MAXCPUS],
  1705.     secondcnt[MAXCPUS];
  1706.  
  1707.   float    
  1708.     elapsed, 
  1709.     temp_rate,
  1710.     rate[MAXTIMES],
  1711.     local_maxrate;
  1712.  
  1713.   long    
  1714.     sec,
  1715.     usec;
  1716.  
  1717.   int    
  1718.     i,
  1719.     j;
  1720.   
  1721.   long    count;
  1722.  
  1723.   struct  timeval time1, time2;
  1724.   struct  timezone tz;
  1725.  
  1726.   struct pst_processor *psp;
  1727.   
  1728.   if (times > MAXTIMES) {
  1729.     times = MAXTIMES;
  1730.   }
  1731.   
  1732.   local_maxrate = -1.0;
  1733.  
  1734.   psp = (struct pst_processor *)malloc(lib_num_loc_cpus * sizeof(*psp));
  1735.  
  1736.   for(i = 0; i < times; i++) {
  1737.     rate[i] = 0.0;
  1738.     /* get the idle sycle counter for each processor */
  1739.     if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
  1740.       for (j = 0; j < lib_num_loc_cpus; j++) {
  1741.     union overlay_u {
  1742.       long long full;
  1743.       long      word[2];
  1744.     } *overlay;
  1745.     overlay = (union overlay_u *)&(firstcnt[j]);
  1746.     overlay->word[0] = psp[j].psp_idlecycles.psc_hi;
  1747.     overlay->word[1] = psp[j].psp_idlecycles.psc_lo;
  1748.       }
  1749.     }
  1750.     else {
  1751.       fprintf(where,"pstat_setprocessor failure errno %d\n");
  1752.       fflush(where);
  1753.       exit(1);
  1754.     }
  1755.  
  1756.     gettimeofday (&time1, &tz);
  1757.     sleep(wait_time);
  1758.     gettimeofday (&time2, &tz);
  1759.     
  1760.     if (time2.tv_usec < time1.tv_usec)
  1761.       {
  1762.     time2.tv_usec += 1000000;
  1763.     time2.tv_sec -=1;
  1764.       }
  1765.     sec = time2.tv_sec - time1.tv_sec;
  1766.     usec = time2.tv_usec - time1.tv_usec;
  1767.     elapsed = (float)sec + ((float)usec/(float)1000000.0);
  1768.  
  1769.     if(debug) {
  1770.       fprintf(where, "Calibration for counter run: %d\n",i);
  1771.       fprintf(where,"\tsec = %ld usec = %ld\n",sec,usec);
  1772.       fprintf(where,"\telapsed time = %g\n",elapsed);
  1773.     }
  1774.  
  1775.     if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
  1776.       for (j = 0; j < lib_num_loc_cpus; j++) {
  1777.     union overlay_u {
  1778.       long long full;
  1779.       long      word[2];
  1780.     } *overlay;
  1781.     overlay = (union overlay_u *)&(secondcnt[j]);
  1782.     overlay->word[0] = psp[j].psp_idlecycles.psc_hi;
  1783.     overlay->word[1] = psp[j].psp_idlecycles.psc_lo;
  1784.     if(debug) {
  1785.       /* I know that there are situations where compilers know about */
  1786.       /* long long, but the library fucntions do not... raj 4/95 */
  1787.       fprintf(where,
  1788.           "\tfirstcnt[%d] = 0x%8.8x%8.8x secondcnt[%d] = 0x%8.8x%8.8x\n",
  1789.           j,
  1790.           hi_32(&firstcnt[j]),
  1791.           lo_32(&firstcnt[j]),
  1792.           j,
  1793.           hi_32(&secondcnt[j]),
  1794.           lo_32(&secondcnt[j]));
  1795.     }
  1796.     temp_rate = (secondcnt[j] >= firstcnt[j]) ? 
  1797.       (float)(secondcnt[j] - firstcnt[j] )/elapsed : 
  1798.         (float)(secondcnt[j] - firstcnt[j] + LONG_LONG_MAX)/elapsed;
  1799.     if (temp_rate > rate[i]) rate[i] = temp_rate;
  1800.     if(debug) {
  1801.       fprintf(where,"\trate[%d] = %g\n",i,rate[i]);
  1802.       fflush(where);
  1803.     }
  1804.     if (local_maxrate < rate[i]) local_maxrate = rate[i];
  1805.       }
  1806.     }
  1807.     else {
  1808.       fprintf(where,"pstat failure; errno %d\n",errno);
  1809.       fflush(where);
  1810.       exit(1);
  1811.     }
  1812.   }
  1813.   if(debug) {
  1814.     fprintf(where,"\tlocal maxrate = %g per sec. \n",local_maxrate);
  1815.     fflush(where);
  1816.   }
  1817.   return local_maxrate;
  1818. }
  1819. #endif /* PSTAT_IPCINFO */
  1820. #endif /* USE_PSTAT */
  1821.  
  1822.  
  1823. void libmain()
  1824. {
  1825. fprintf(where,"hello world\n");
  1826. fprintf(where,"debug: %d\n",debug);
  1827. }
  1828.  
  1829. /****************************************************************/
  1830. /*                                */
  1831. /*    establish_control()                    */
  1832. /*                                */
  1833. /* set-up the control connection between me and the server so    */
  1834. /* we can actually run some tests. if we cannot establish the   */
  1835. /* control connection, we might as well punt...            */
  1836. /* the variables for the control socket are kept in this lib    */
  1837. /* so as to 'hide' them from the upper routines as much as    */
  1838. /* possible so we can change them without affecting anyone...    */
  1839. /****************************************************************/
  1840.  
  1841. struct    sockaddr_in    server;         /* remote host address          */
  1842. struct    servent        *sp;            /* server entity                */
  1843. struct    hostent        *hp;            /* host entity                  */
  1844.  
  1845. void 
  1846. establish_control(hostname,port)
  1847. char         hostname[];
  1848. short int    port;
  1849. {
  1850.  
  1851.   unsigned int addr;
  1852.  
  1853.   if (debug > 1) {
  1854.     fprintf(where,"establish_control: entered with %s and %d\n",
  1855.         hostname,
  1856.         port);
  1857.   }
  1858.  
  1859.   /********************************************************/
  1860.   /* Set up the control socket netlib_control first    */
  1861.   /* for the time being we will assume that all set-ups    */
  1862.   /* are for tcp/ip and sockets...            */
  1863.   /********************************************************/
  1864.   
  1865.   bzero((char *)&server,
  1866.     sizeof(server));
  1867.   server.sin_port = htons(port);
  1868.  
  1869.   /* it would seem that while HP-UX will allow an IP address (as a */
  1870.   /* string) in a call to gethostbyname, other, less enlightened */
  1871.   /* systems do not. fix from awjacks@ca.sandia.gov raj 10/95 */  
  1872.   if ((hp = gethostbyname(hostname)) == NULL) {
  1873.     if ((addr = inet_addr(hostname)) == -1) {
  1874.       fprintf(where,
  1875.           "establish_control: could not resolve the name %s\n",
  1876.           hostname);
  1877.       fflush(where);
  1878.       exit(1);
  1879.     }
  1880.     server.sin_addr.s_addr = addr;
  1881.     server.sin_family = AF_INET;
  1882.   }
  1883.   else {
  1884.     bcopy(hp->h_addr,
  1885.       (char *)&server.sin_addr,
  1886.       hp->h_length);
  1887.     server.sin_family = hp->h_addrtype;
  1888.   }
  1889.   
  1890.   
  1891.   if (debug > 1) {
  1892.     fprintf(where,"got the host info... \n");
  1893.     fflush(where);
  1894.   }
  1895.   
  1896.   
  1897.   if (debug > 1) {
  1898.     fprintf(where,"creating a socket\n");
  1899.     fflush(stdout);
  1900.   }
  1901.  
  1902. #ifdef __EMX__
  1903.   if(hp == NULL)
  1904.   {
  1905.     netlib_control = socket(PF_INET,
  1906.             SOCK_STREAM,
  1907.             tcp_proto_num);
  1908.   }
  1909.   else
  1910.     netlib_control = socket(hp->h_addrtype,
  1911.           SOCK_STREAM,
  1912.           tcp_proto_num);
  1913. #else
  1914.   
  1915.   netlib_control = socket(hp->h_addrtype,
  1916.               SOCK_STREAM,
  1917.               tcp_proto_num);
  1918. #endif
  1919.   
  1920.   if (netlib_control < 0){
  1921.     perror("establish_control: control socket");
  1922.     exit(1);
  1923.   }
  1924.   
  1925.   if (debug > 1) {
  1926.     fprintf(where,"about to connect\n");
  1927.     fflush(stdout);
  1928.   }
  1929.   
  1930.   if (connect(netlib_control, 
  1931.           (struct sockaddr *)&server, 
  1932.           sizeof(server)) <0){
  1933.     perror("establish_control: control socket connect failed");
  1934.     exit(1);
  1935.   }
  1936.   if (debug) {
  1937.     fprintf(where,"establish_control: connect completes\n");
  1938.   }
  1939.   
  1940.   /********************************************************/
  1941.   /* The Control Socket set-up is done, so now we want    */
  1942.   /* to test for connectivity on the connection        */
  1943.   /********************************************************/
  1944.  
  1945.   if (debug) 
  1946.     netperf_request.content.request_type = DEBUG_ON;
  1947.   else
  1948.     netperf_request.content.request_type = DEBUG_OFF;
  1949.   
  1950.   send_request();
  1951.   recv_response();
  1952.   
  1953.   if (netperf_response.content.response_type != DEBUG_OK) {
  1954.     fprintf(stderr,"establish_control: Unknown response to debug check\n");
  1955.     exit(1);
  1956.   }
  1957.   else if(debug)
  1958.     fprintf(where,"establish_control: check for connectivity ok\n");
  1959.   
  1960. }
  1961.  
  1962.  
  1963.  
  1964.  /***********************************************************************/
  1965.  /*                                    */
  1966.  /*    get_id()                            */
  1967.  /*                                    */
  1968.  /* Return a string to the calling routine that contains the        */
  1969.  /* identifying information for the host we are running on. This    */
  1970.  /* information will then either be displayed locally, or returned to    */
  1971.  /* a remote caller for display there.                    */
  1972.  /*                                    */
  1973.  /***********************************************************************/
  1974.  
  1975. void
  1976. get_id(id_string)
  1977. char *id_string;
  1978. {
  1979. #ifdef WIN32
  1980. SYSTEM_INFO        system_info ;
  1981. char            system_name[MAX_COMPUTERNAME_LENGTH+1] ;
  1982. int            name_len = MAX_COMPUTERNAME_LENGTH + 1 ;
  1983. #else
  1984. struct    utsname        system_name;
  1985. #endif /* WIN32 */
  1986.  
  1987. #ifdef WIN32
  1988. GetSystemInfo( &system_info ) ;
  1989. if ( !GetComputerName(system_name , &name_len) )
  1990.     strcpy(system_name , "no_name") ;
  1991. #else
  1992. if (uname(&system_name) <0) {
  1993.     perror("identify_local: uname");
  1994.     exit(1);
  1995. }
  1996. #endif /* WIN32 */
  1997.  
  1998. sprintf(id_string,
  1999. #ifdef WIN32
  2000.     "%-15s%-15s%d.%d%-15s",
  2001.     "Windows NT",
  2002.     system_name ,
  2003.     GetVersion() & 0xFF ,
  2004.     GetVersion() & 0xFF00 ,
  2005.     system_info.dwProcessorType ) ;
  2006.     
  2007. #else
  2008.     "%-15s%-15s%-15s%-15s%-15s",
  2009.     system_name.sysname,
  2010.     system_name.nodename,
  2011.     system_name.release,
  2012.     system_name.version,
  2013.     system_name.machine);
  2014. #endif /* WIN32 */
  2015. }
  2016.  
  2017.  
  2018.  /***********************************************************************/
  2019.  /*                                    */
  2020.  /*    identify_local()                        */
  2021.  /*                                    */
  2022.  /* Display identifying information about the local host to the user.    */
  2023.  /* At first release, this information will be the same as that which    */
  2024.  /* is returned by the uname -a command, with the exception of the    */
  2025.  /* idnumber field, which seems to be a non-POSIX item, and hence    */
  2026.  /* non-portable.                            */
  2027.  /*                                    */
  2028.  /***********************************************************************/
  2029.  
  2030. void
  2031. identify_local()
  2032. {
  2033.  
  2034. char    local_id[80];
  2035.  
  2036. get_id(local_id);
  2037.  
  2038. fprintf(where,"Local Information \n\
  2039. Sysname       Nodename       Release        Version        Machine\n");
  2040.  
  2041. fprintf(where,"%s\n",
  2042.        local_id);
  2043.  
  2044. }
  2045.  
  2046.  
  2047.  /***********************************************************************/
  2048.  /*                                    */
  2049.  /*    identify_remote()                        */
  2050.  /*                                    */
  2051.  /* Display identifying information about the remote host to the user.    */
  2052.  /* At first release, this information will be the same as that which    */
  2053.  /* is returned by the uname -a command, with the exception of the    */
  2054.  /* idnumber field, which seems to be a non-POSIX item, and hence    */
  2055.  /* non-portable. A request is sent to the remote side, which will    */
  2056.  /* return a string containing the utsname information in a        */
  2057.  /* pre-formatted form, which is then displayed after the header.    */
  2058.  /*                                    */
  2059.  /***********************************************************************/
  2060.  
  2061. void
  2062. identify_remote()
  2063. {
  2064.  
  2065. char    *remote_id="";
  2066.  
  2067. /* send a request for node info to the remote */
  2068. netperf_request.content.request_type = NODE_IDENTIFY;
  2069.  
  2070. send_request();
  2071.  
  2072. /* and now wait for the reply to come back */
  2073.  
  2074. recv_response();
  2075.  
  2076. if (netperf_response.content.serv_errno) {
  2077.     errno = netperf_response.content.serv_errno;
  2078.     perror("identify_remote: on remote");
  2079.     exit(1);
  2080. }
  2081.  
  2082. fprintf(where,"Remote Information \n\
  2083. Sysname       Nodename       Release        Version        Machine\n");
  2084.  
  2085. fprintf(where,"%s",
  2086.        remote_id);
  2087. }
  2088.  
  2089. void
  2090. cpu_start(measure_cpu)
  2091.      int measure_cpu;
  2092. {
  2093.  
  2094.   int    i;
  2095.  
  2096.   gettimeofday(&time1,
  2097.            &tz);
  2098.   
  2099.   if (measure_cpu) {
  2100.     measuring_cpu = 1;
  2101. #ifdef USE_LOOPER
  2102.     cpu_method = LOOPER;
  2103.     for (i = 0; i < lib_num_loc_cpus; i++){
  2104.       lib_start_count[i] = *lib_idle_address[i];
  2105.     }
  2106. #else
  2107. #ifdef    USE_PSTAT
  2108.     cpu_method = PSTAT;
  2109. #ifdef PSTAT_IPCINFO
  2110.     /* we need to know if we have the 10.0 pstat interface */
  2111.     /* available. I know that at 10.0, the define for PSTAT_IPCINFO */
  2112.     /* was added, but that it is not there prior. so, this should */
  2113.     /* act as the automagic compile trigger that I need. raj 4/95 */
  2114.     cpu_method = HP_IDLE_COUNTER;
  2115.     {
  2116.       /* get the idle sycle counter for each processor */
  2117.       struct pst_processor *psp;
  2118.       union overlay_u {
  2119.     long long full;
  2120.     long      word[2];
  2121.       } *overlay;
  2122.       
  2123.       psp = (struct pst_processor *)malloc(lib_num_loc_cpus * sizeof(*psp));
  2124.       if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
  2125.     int i;
  2126.     for (i = 0; i < lib_num_loc_cpus; i++) {
  2127.       overlay = (union overlay_u *)&(lib_start_count[i]);
  2128.       overlay->word[0] = psp[i].psp_idlecycles.psc_hi;
  2129.       overlay->word[1] = psp[i].psp_idlecycles.psc_lo;
  2130.       if(debug) {
  2131.         fprintf(where,
  2132.             "\tlib_start_count[%d] = 0x%8.8x%8.8x\n",
  2133.             i,
  2134.             hi_32(&lib_start_count[i]),
  2135.             lo_32(&lib_start_count[i]));
  2136.         fflush(where);
  2137.       }
  2138.     }
  2139.     free(psp);
  2140.       }
  2141.     }
  2142. #else
  2143.     /* this is what we should get when compiling on an HP-UX 9.X */
  2144.     /* system. raj 4/95 */
  2145.     pstat_getdynamic((struct pst_dynamic *)&pst_dynamic_info,
  2146.              sizeof(pst_dynamic_info),1,0);
  2147.     for (i = 0; i < PST_MAX_CPUSTATES; i++) {
  2148.       cp_time1[i] = pst_dynamic_info.psd_cpu_time[i];
  2149.     }
  2150. #endif /* PSTAT_IPCINFO */
  2151. #else
  2152. #ifdef WIN32
  2153. #ifdef NT_SDK
  2154.     /*--------------------------------------------------*/      /* robin */
  2155.     /* Use Win/NT internal counters to measure CPU%     */      /* robin */
  2156.     /*--------------------------------------------------*/      /* robin */
  2157.     NTSTATUS status;                                            /* robin */
  2158.                                                                 /* robin */
  2159.     status = NtQuerySystemTime( &systime_start );               /* robin */
  2160.     if (debug) {                                                /* robin */
  2161.        if (!NT_SUCCESS(status)) {                               /* robin */
  2162.           fprintf(where,"NtQuerySystemTime "                    /* robin */
  2163.                         "failed: 0x%08X\n",                     /* robin */
  2164.                         status);                                /* robin */
  2165.        }                                                        /* robin */
  2166.     }                                                           /* robin */
  2167.                                                                 /* robin */
  2168.     status = NtQuerySystemInformation (                         /* robin */
  2169.                 SystemProcessorPerformanceInformation,          /* robin */
  2170.                 &sysperf_start,                                 /* robin */
  2171.                 sizeof(sysperf_start),                          /* robin */
  2172.                 NULL );                                         /* robin */
  2173.                                                                 /* robin */
  2174.     if (debug) {                                                /* robin */
  2175.        if (!NT_SUCCESS(status)) {                               /* robin */
  2176.           fprintf(where,"NtQuerySystemInformation "             /* robin */
  2177.                         "failed: 0x%08X\n",                     /* robin */
  2178.                         status);                                /* robin */
  2179.        }                                                        /* robin */
  2180.     }                                                           /* robin */
  2181.                                                                 /* robin */
  2182. #endif /* NT_SDK */
  2183. #else
  2184.     cpu_method = TIMES;
  2185.     times(×_data1);
  2186. #endif /* WIN32 */
  2187. #endif /* USE_PSTAT */
  2188. #endif /* USE_LOOPER */
  2189.   }
  2190. }
  2191.  
  2192.  
  2193. void
  2194. cpu_stop(measure_cpu,elapsed)
  2195. int    measure_cpu;
  2196. float    *elapsed;
  2197. {
  2198. #ifndef WIN32
  2199. #include <sys/wait.h>
  2200. #endif /* WIN32 */
  2201.  
  2202. int    sec,
  2203.         usec;
  2204.  
  2205. int    i;
  2206.  
  2207. if (measure_cpu) {
  2208. #ifdef USE_LOOPER
  2209.   for (i = 0; i < lib_num_loc_cpus; i++){
  2210.     lib_end_count[i] = *lib_idle_address[i];
  2211.   }
  2212. #ifdef WIN32
  2213.   /* it would seem that if/when the process exits, all the threads */
  2214.   /* will go away too, so I don't think I need any explicit thread */
  2215.   /* killing calls here. raj 1/96 */
  2216. #else
  2217.   /* now go through and kill-off all the child processes */
  2218.   for (i = 0; i < lib_num_loc_cpus; i++){
  2219.     kill(lib_idle_pids[i],SIGQUIT);
  2220.   }
  2221.   /* reap the children */
  2222.   while(waitpid(-1, NULL, WNOHANG) > 0) { }
  2223.   
  2224.   /* finally, unlink the mmaped file */
  2225.   munmap((caddr_t)lib_base_pointer,
  2226.      ((NETPERF_PAGE_SIZE * PAGES_PER_CHILD) * 
  2227.       lib_num_loc_cpus));
  2228.   unlink("/tmp/netperf_cpu");
  2229. #endif /* WIN32 */
  2230. #else
  2231. #ifdef    USE_PSTAT
  2232. #ifdef PSTAT_IPCINFO
  2233.   {
  2234.     struct pst_processor *psp;
  2235.     union overlay_u {
  2236.       long long full;
  2237.       long      word[2];
  2238.     } *overlay;
  2239.     psp = (struct pst_processor *)malloc(lib_num_loc_cpus * sizeof(*psp));
  2240.     if (pstat_getprocessor(psp, sizeof(*psp), lib_num_loc_cpus, 0) != -1) {
  2241.       for (i = 0; i < lib_num_loc_cpus; i++) {
  2242.     overlay = (union overlay_u *)&(lib_end_count[i]);
  2243.     overlay->word[0] = psp[i].psp_idlecycles.psc_hi;
  2244.     overlay->word[1] = psp[i].psp_idlecycles.psc_lo;
  2245.     if(debug) {
  2246.       fprintf(where,
  2247.           "\tlib_end_count[%d]   = 0x%8.8x%8.8x\n",
  2248.           i,
  2249.           hi_32(&lib_end_count[i]),
  2250.           lo_32(&lib_end_count[i]));
  2251.       fflush(where);
  2252.     }
  2253.       }
  2254.       free(psp);
  2255.     }
  2256.     else {
  2257.       fprintf(where,"pstat_getprocessor failure: errno %d\n",errno);
  2258.       fflush(where);
  2259.       exit(1);
  2260.     }
  2261.   }
  2262. #else /* not HP-UX 10.0 or later */
  2263.   {
  2264.     pstat_getdynamic(&pst_dynamic_info, sizeof(pst_dynamic_info),1,0);
  2265.     for (i = 0; i < PST_MAX_CPUSTATES; i++) {
  2266.       cp_time2[i] = pst_dynamic_info.psd_cpu_time[i];
  2267.     }
  2268.   }    
  2269. #endif /* PSTAT_IPC_INFO */
  2270. #else
  2271. #ifdef WIN32
  2272. #ifdef NT_SDK
  2273.        NTSTATUS status;                                         /* robin */
  2274.                                                                 /* robin */
  2275.        status = NtQuerySystemTime( &systime_end );              /* robin */
  2276.        if (debug) {                                             /* robin */
  2277.           if (!NT_SUCCESS(status)) {                            /* robin */
  2278.              fprintf(where,"NtQuerySystemTime "                 /* robin */
  2279.                            "failed: 0x%08X\n",                  /* robin */
  2280.                            status);                             /* robin */
  2281.           }                                                     /* robin */
  2282.        }                                                        /* robin */
  2283.        status = NtQuerySystemInformation (                      /* robin */
  2284.                    SystemProcessorPerformanceInformation,       /* robin */
  2285.                    &sysperf_end,                                /* robin */
  2286.                    sizeof(sysperf_end),                         /* robin */
  2287.                    NULL );                                      /* robin */
  2288.                                                                 /* robin */
  2289.        if (debug) {                                             /* robin */
  2290.           if (!NT_SUCCESS(status)) {                            /* robin */
  2291.              fprintf(where,"NtQuerySystemInformation "          /* robin */
  2292.                            "failed: 0x%08X\n",                  /* robin */
  2293.                            status);                             /* robin */
  2294.           }                                                     /* robin */
  2295.        }                                                        /* robin */
  2296.                                                                 /* robin */
  2297. #endif /* NT_SDK */
  2298. #else
  2299.   times(×_data2);
  2300. #endif /* WIN32 */
  2301. #endif /* USE_PSTAT */
  2302. #endif /* USE_LOOPER */
  2303. }
  2304.  
  2305. gettimeofday(&time2,
  2306.          &tz);
  2307.  
  2308. if (time2.tv_usec < time1.tv_usec) {
  2309.   time2.tv_usec    += 1000000;
  2310.   time2.tv_sec    -= 1;
  2311. }
  2312.  
  2313. sec    = time2.tv_sec - time1.tv_sec;
  2314. usec    = time2.tv_usec - time1.tv_usec;
  2315. lib_elapsed    = (float)sec + ((float)usec/(float)1000000.0);
  2316.  
  2317. *elapsed = lib_elapsed;
  2318.     
  2319. }
  2320.  
  2321. double
  2322. calc_thruput(units_received)
  2323. double units_received;
  2324.  
  2325. {
  2326.   double    divisor;
  2327.  
  2328.   /* We will calculate the thruput in libfmt units/second */
  2329.   switch (libfmt) {
  2330.   case 'K':
  2331.     divisor = 1024.0;
  2332.     break;
  2333.   case 'M':
  2334.     divisor = 1024.0 * 1024.0;
  2335.     break;
  2336.   case 'G':
  2337.     divisor = 1024.0 * 1024.0 * 1024.0;
  2338.     break;
  2339.   case 'k':
  2340.     divisor = 1000.0 / 8.0;
  2341.     break;
  2342.   case 'm':
  2343.     divisor = 1000.0 * 1000.0 / 8.0;
  2344.     break;
  2345.   case 'g':
  2346.     divisor = 1000.0 * 1000.0 * 1000.0 / 8.0;
  2347.     break;
  2348.     
  2349.   default:
  2350.     divisor = 1024.0;
  2351.   }
  2352.   
  2353.   return (units_received / divisor / lib_elapsed);
  2354.  
  2355. }
  2356.  
  2357.  
  2358.  
  2359.  
  2360. float 
  2361. calc_cpu_util(elapsed_time)
  2362.      float elapsed_time;
  2363. {
  2364.   
  2365.   float    actual_rate;
  2366.   float correction_factor;
  2367. #ifdef USE_PSTAT
  2368. #ifdef PSTAT_IPCINFO
  2369.   float temp_util;
  2370. #else
  2371.   long diff;
  2372. #endif
  2373. #endif
  2374.   int    cpu_time_ticks;
  2375.   long    ticks_sec;
  2376.   int    i;
  2377.   
  2378.  
  2379.   lib_local_cpu_util = (float)0.0;
  2380.   /* It is possible that the library measured a time other than */
  2381.   /* the one that the user want for the cpu utilization */
  2382.   /* calculations - for example, tests that were ended by */
  2383.   /* watchdog timers such as the udp stream test. We let these */
  2384.   /* tests tell up what the elapsed time should be. */
  2385.   
  2386.   if (elapsed_time != 0.0) {
  2387.     correction_factor = (float) 1.0 + 
  2388.       ((lib_elapsed - elapsed_time) / elapsed_time);
  2389.   }
  2390.   else {
  2391.     correction_factor = (float) 1.0;
  2392.   }
  2393.   
  2394. #ifdef USE_LOOPER
  2395.   for (i = 0; i < lib_num_loc_cpus; i++) {
  2396.  
  2397.     /* it would appear that on some systems, in loopback, nice */
  2398.     /* is *very* effective, causing the looper process to stop */
  2399.     /* dead in its tracks. if this happens, we need to ensure  */
  2400.     /* that the calculation does not go south. raj 6/95        */
  2401.     if (lib_end_count[i] == lib_start_count[i]) {
  2402.       lib_end_count[i]++;
  2403.     }
  2404.     
  2405.     actual_rate = (lib_end_count[i] > lib_start_count[i]) ?
  2406.       (float)(lib_end_count[i] - lib_start_count[i])/lib_elapsed :
  2407.     (float)(lib_end_count[i] - lib_start_count[i] +
  2408.         MAXLONG)/ lib_elapsed;
  2409.     if (debug) {
  2410.       fprintf(where,
  2411.           "calc_cpu_util: actual_rate on processor %d is %f\n",
  2412.           i,
  2413.           actual_rate);
  2414.     }
  2415.     lib_local_cpu_util += (lib_local_maxrate - actual_rate) /
  2416.       lib_local_maxrate * 100;
  2417.   }
  2418.   /* we want the average across all n processors */
  2419.   lib_local_cpu_util /= (float)lib_num_loc_cpus;
  2420.  
  2421. #else
  2422. #ifdef USE_PSTAT
  2423. #ifdef PSTAT_IPCINFO
  2424.   {
  2425.     /* this looks just like the looper case. at least I think it */
  2426.     /* should :) raj 4/95 */
  2427.     for (i = 0; i < lib_num_loc_cpus; i++) {
  2428.       /* we assume that the two are not more than a long apart. I */
  2429.       /* know that this is bad, but trying to go from long longs to */
  2430.       /* a float (perhaps a double) is boggling my mind right now. */
  2431.       /* raj 4/95 */
  2432.  
  2433.       long long 
  2434.     diff;
  2435.       
  2436.       if (lib_end_count[i] >= lib_start_count[i]) {
  2437.     diff = lib_end_count[i] - lib_start_count[i];
  2438.       }
  2439.       else {
  2440.     diff = lib_end_count[i] - lib_start_count[i] + LONG_LONG_MAX;
  2441.       }
  2442.       actual_rate = (float) diff / lib_elapsed;
  2443.       temp_util = (lib_local_maxrate - actual_rate) /
  2444.     lib_local_maxrate * 100;
  2445.       lib_local_cpu_util += temp_util;
  2446.       if (debug) {
  2447.     fprintf(where,
  2448.         "calc_cpu_util: actual_rate on cpu %d is %f cpu %6.2f\n",
  2449.         i,
  2450.         actual_rate,
  2451.         temp_util);
  2452.       }
  2453.     }
  2454.     /* we want the average across all n processors */
  2455.     lib_local_cpu_util /= (float)lib_num_loc_cpus;
  2456.   }
  2457. #else
  2458.   {
  2459.     /* we had no idle counter, but there was a pstat. we */
  2460.     /* will use the cpu_time_ticks variable for the total */
  2461.     /* ticks calculation */
  2462.     cpu_time_ticks = 0;
  2463.     /* how many ticks were there in our interval? */
  2464.     for (i = 0; i < PST_MAX_CPUSTATES; i++) {
  2465.       diff = cp_time2[i] - cp_time1[i];
  2466.       cpu_time_ticks += diff;
  2467.       if (debug) {
  2468.     fprintf(where,
  2469.         "%d cp_time1 %d cp_time2 %d diff %d cpu_time_ticks is %d \n",
  2470.         i,
  2471.         cp_time1[i],
  2472.         cp_time2[i],
  2473.         diff,
  2474.         cpu_time_ticks);
  2475.     fflush(where);
  2476.       }
  2477.     }
  2478.     if (!cpu_time_ticks)
  2479.       cpu_time_ticks = 1;
  2480.     /* cpu used is 100% minus the idle time - right ?-) */
  2481.     lib_local_cpu_util = 1.0 - ( ((float)(cp_time2[CP_IDLE] - 
  2482.                       cp_time1[CP_IDLE]))
  2483.                 / (float)cpu_time_ticks);
  2484.     lib_local_cpu_util *= 100.0;
  2485.     if (debug) {
  2486.       fprintf(where,
  2487.           "calc_cpu_util has cpu_time_ticks at %d\n",cpu_time_ticks);
  2488.       fprintf(where,"sysconf ticks is %g\n",
  2489.           sysconf(_SC_CLK_TCK) * lib_elapsed);
  2490.       fprintf(where,"calc_cpu_util has idle_ticks at %d\n",
  2491.           (cp_time2[CP_IDLE] - cp_time1[CP_IDLE]));
  2492.       fflush(where);
  2493.     }
  2494.   }
  2495. #endif /* PSTAT_IPCINFO */
  2496. #else
  2497. #ifdef WIN32
  2498. #ifdef NT_SDK
  2499.   LARGE_INTEGER delta_t,    /* scratch */                       /* robin */
  2500.                 elapsed,    /* elapsed total system time */     /* robin */
  2501.                 kernel,     /* elapsed kernel mode time  */     /* robin */
  2502.                 idle,       /* elapsed kernel idle time  */     /* robin */
  2503.                 user;       /* elapsed user mode time    */     /* robin */
  2504.   ULONG         remainder;  /* never used, discarded value */   /* robin */
  2505.   ULONG         cpu;        /* cpu utilization (as ULONG)  */   /* robin */
  2506.                                                                 /* robin */
  2507.   /* The magic number 10*1000 will convert the  */              /* robin */
  2508.   /* 100ns time units (returned by NT kernel)   */              /* robin */
  2509.   /* into millisecond units.                    */              /* robin */
  2510.   delta_t = RtlLargeIntegerSubtract(                            /* robin */
  2511.                        systime_end,                             /* robin */
  2512.                        systime_start);                          /* robin */
  2513.   elapsed = RtlExtendedLargeIntegerDivide(                      /* robin */
  2514.                        delta_t,                                 /* robin */
  2515.                        10*1000,                                 /* robin */
  2516.                        &remainder);                             /* robin */
  2517.   if (debug) {
  2518.     fprintf(where,
  2519.         "NT's elapsed time %d\n",
  2520.         remainder);
  2521.     fflush(where);
  2522.   }
  2523.  
  2524.   delta_t = RtlLargeIntegerSubtract(                            /* robin */
  2525.                        sysperf_end.KernelTime,                  /* robin */
  2526.                        sysperf_start.KernelTime);               /* robin */
  2527.   kernel  = RtlExtendedLargeIntegerDivide(                      /* robin */
  2528.                        delta_t,                                 /* robin */
  2529.                        10*1000,                                 /* robin */
  2530.                        &remainder);                             /* robin */
  2531.   if (debug) {
  2532.     fprintf(where,
  2533.         " kernel time %d ",
  2534.         kernel);
  2535.     fflush(where);
  2536.   }
  2537.  
  2538.   delta_t = RtlLargeIntegerSubtract(                            /* robin */
  2539.                        sysperf_end.IdleTime,                    /* robin */
  2540.                        sysperf_start.IdleTime);                 /* robin */
  2541.   idle    = RtlExtendedLargeIntegerDivide(                      /* robin */
  2542.                        delta_t,                                 /* robin */
  2543.                        10*1000,                                 /* robin */
  2544.                        &remainder);                             /* robin */
  2545.   if (debug) {
  2546.     fprintf(where,
  2547.         " idle time %d ",
  2548.         idle);
  2549.     fflush(where);
  2550.   }
  2551.  
  2552.   delta_t = RtlLargeIntegerSubtract(                            /* robin */
  2553.                        sysperf_end.UserTime,                    /* robin */
  2554.                        sysperf_start.UserTime);                 /* robin */
  2555.   user    = RtlExtendedLargeIntegerDivide(                      /* robin */
  2556.                        delta_t,                                 /* robin */
  2557.                        10*1000,                                 /* robin */
  2558.                        &remainder);                             /* robin */
  2559.  
  2560.   if (debug) {
  2561.     fprintf(where,
  2562.         " user time %d\n",
  2563.         user);
  2564.     fflush(where);
  2565.   }
  2566.  
  2567.                                                                 /* robin */
  2568.   cpu = ((kernel.LowPart+user.LowPart-idle.LowPart)*100 + 50)   /* robin */
  2569.                       /elapsed.LowPart;                         /* robin */
  2570.   lib_local_cpu_util = (float)cpu;                              /* robin */
  2571.                                                                 /* robin */
  2572.                                                                 /* robin */
  2573.   if (debug) {                                                  /* robin */
  2574.      fprintf(where,"calc_cpu_util: local_cpu_util = %ld%%\n",   /* robin */
  2575.                    cpu);                                        /* robin */
  2576.   }                                                             /* robin */
  2577.                                                                 /* robin */
  2578. #endif /* NT_SDK */
  2579. #else
  2580.   /* we had no kernel idle counter, so use what we can */
  2581.   ticks_sec = sysconf(_SC_CLK_TCK);
  2582.   cpu_time_ticks = ((times_data2.tms_utime - times_data1.tms_utime) +
  2583.             (times_data2.tms_stime -
  2584.              times_data1.tms_stime));
  2585.   
  2586.   if (debug) {
  2587.     fprintf(where,"calc_cpu_util has cpu_time_ticks at %d\n",cpu_time_ticks);
  2588.     fprintf(where,"calc_cpu_util has tick_sec at %ld\n",ticks_sec);
  2589.     fprintf(where,"calc_cpu_util has lib_elapsed at %f\n",lib_elapsed);
  2590.     fflush(where);
  2591.   }
  2592.   
  2593.   lib_local_cpu_util = (float) (((double) (cpu_time_ticks) /
  2594.                  (double) ticks_sec /
  2595.                  (double) lib_elapsed) *
  2596.                 (double) 100.0);
  2597. #endif /* WIN32 */
  2598. #endif /* USE_PSTAT */
  2599. #endif /* USE_LOOPER */
  2600.   lib_local_cpu_util *= correction_factor;
  2601.   return lib_local_cpu_util;
  2602. }
  2603.  
  2604. float calc_service_demand(units_sent,
  2605.               elapsed_time,
  2606.               cpu_utilization,
  2607.               num_cpus)
  2608. double    units_sent;
  2609. float    elapsed_time;
  2610. float    cpu_utilization;
  2611. int     num_cpus;
  2612.  
  2613. {
  2614.  
  2615.   double unit_divisor = (float)1024.0;
  2616.   double service_demand;
  2617.   double thruput;
  2618.  
  2619.   if (debug) {
  2620.     fprintf(where,"calc_service_demand called:  units_sent = %f\n",
  2621.         units_sent);
  2622.     fprintf(where,"                             elapsed_time = %f\n",
  2623.         elapsed_time);
  2624.     fprintf(where,"                             cpu_util = %f\n",
  2625.         cpu_utilization);
  2626.     fprintf(where,"                             num cpu = %d\n",
  2627.         num_cpus);
  2628.     fflush(where);
  2629.   }
  2630.  
  2631.   if (num_cpus == 0) num_cpus = lib_num_loc_cpus;
  2632.   
  2633.   if (elapsed_time == 0.0) {
  2634.     elapsed_time = lib_elapsed;
  2635.   }
  2636.   if (cpu_utilization == 0.0) {
  2637.     cpu_utilization = lib_local_cpu_util;
  2638.   }
  2639.   
  2640.   thruput = (units_sent / 
  2641.          (double) unit_divisor / 
  2642.          (double) elapsed_time);
  2643.  
  2644.   /* on MP systems, it is necessary to multiply the service demand by */
  2645.   /* the number of CPU's. at least, I believe that to be the case:) */
  2646.   /* raj 10/95 */
  2647.  
  2648.   /* thruput has a "per second" component. if we were using 100% ( */
  2649.   /* 100.0) of the CPU in a second, that would be 1 second, or 1 */
  2650.   /* millisecond, so we multiply cpu_utilization by 10 to go to */
  2651.   /* milliseconds, or 10,000 to go to micro seconds. With revision */
  2652.   /* 2.1, the service demand measure goes to microseconds per unit. */
  2653.   /* raj 12/95 */ 
  2654.   service_demand = (cpu_utilization*10000.0/thruput) * 
  2655.     (float) num_cpus;
  2656.   
  2657.   if (debug) {
  2658.     fprintf(where,"calc_service_demand using:   units_sent = %f\n",
  2659.         units_sent);
  2660.     fprintf(where,"                             elapsed_time = %f\n",
  2661.         elapsed_time);
  2662.     fprintf(where,"                             cpu_util = %f\n",
  2663.         cpu_utilization);
  2664.     fprintf(where,"                             num cpu = %d\n",
  2665.         num_cpus);
  2666.     fprintf(where,"calc_service_demand got:     thruput = %f\n",
  2667.         thruput);
  2668.     fprintf(where,"                             servdem = %f\n",
  2669.         service_demand);
  2670.     fflush(where);
  2671.   }
  2672.   return service_demand;
  2673. }
  2674.  
  2675.  
  2676. #ifdef USE_LOOPER
  2677. void
  2678. bind_to_processor(child_num)
  2679.      int child_num;
  2680. {
  2681.   /* This routine will bind the calling process to a particular */
  2682.   /* processor. We are not choosy as to which processor, so it will be */
  2683.   /* the process id mod the number of processors - shifted by one for */
  2684.   /* those systems which name processor starting from one instead of */
  2685.   /* zero. on those systems where I do not yet know how to bind a */
  2686.   /* process to a processor, this routine will be a no-op raj 10/95 */
  2687.  
  2688.   /* just as a reminder, this is *only* for the looper processes, not */
  2689.   /* the actual measurement processes. those will, should, MUST float */
  2690.   /* or not float from CPU to CPU as controlled by the operating */
  2691.   /* system defaults. raj 12/95 */
  2692.  
  2693. #ifdef __hpux
  2694. #include <sys/syscall.h>
  2695. #include <sys/mp.h>
  2696.  
  2697.   int old_cpu = -2;
  2698.  
  2699.   if (debug) {
  2700.     fprintf(where,
  2701.         "child %d asking for CPU %d as pid %d with %d CPUs\n",
  2702.         child_num,
  2703.         (child_num % lib_num_loc_cpus),
  2704.         getpid(),
  2705.         lib_num_loc_cpus);
  2706.     fflush(where);
  2707.   }
  2708.  
  2709.   SETPROCESS((child_num % lib_num_loc_cpus), getpid());
  2710.   return;
  2711.  
  2712. #else
  2713. #ifdef __sun
  2714.  /* this may also get SunOS, which may not have this stuff? */
  2715. #include <sys/processor.h>
  2716. #include <sys/procset.h>
  2717.  
  2718.   int old_binding;
  2719.  
  2720.   if (debug) {
  2721.     fprintf(where,
  2722.         "bind_to_processor: child %d asking for CPU %d as pid %d with %d CPUs\n",
  2723.         child_num,
  2724.         (child_num % lib_num_loc_cpus),
  2725.         getpid(),
  2726.         lib_num_loc_cpus);
  2727.     fflush(where);
  2728.   }
  2729.  
  2730.   if (processor_bind(P_PID,
  2731.              getpid(),
  2732.              (child_num % lib_num_loc_cpus), 
  2733.               &old_binding) != 0) {
  2734.     fprintf(where,"bind_to_processor: unable to perform processor binding\n");
  2735.     fprintf(where,"                   errno %d\n",errno);
  2736.     fflush(where);
  2737.   }
  2738.   return;
  2739. #else
  2740.   return;
  2741. #endif /* __sun */
  2742. #endif /* __hpux */
  2743. }
  2744.  
  2745.  
  2746.  
  2747.  /* sit_and_spin will just spin about incrementing a value */
  2748.  /* this value will either be in a memory mapped region on Unix shared */
  2749.  /* by each looper process, or something appropriate on Windows/NT */
  2750.  /* (malloc'd or such). This routine is reasonably ugly in that it has */
  2751.  /* priority manipulating code for lots of different operating */
  2752.  /* systems. This routine never returns. raj 1/96 */ 
  2753.  
  2754. void
  2755. sit_and_spin(child_index)
  2756.      int child_index;
  2757.  
  2758. {
  2759.   long *my_counter_ptr;
  2760.  
  2761.  /* only use C stuff if we are not WIN32 unless and until we */
  2762.  /* switch from CreateThread to _beginthread. raj 1/96 */
  2763. #ifndef WIN32
  2764.   /* we are the child. we could decide to exec some separate */
  2765.   /* program, but that doesn't really seem worthwhile - raj 4/95 */
  2766.   if (debug > 1) {
  2767.     fprintf(where,
  2768.         "Looper child %d is born, pid %d\n",
  2769.         child_index,
  2770.         getpid());
  2771.     fflush(where);
  2772.   }
  2773.   
  2774. #endif /* WIN32 */
  2775.  
  2776.   /* reset our base pointer to be at the appropriate offset */
  2777.   my_counter_ptr = (long *) ((char *)lib_base_pointer + 
  2778.                  (NETPERF_PAGE_SIZE * 
  2779.                   PAGES_PER_CHILD * child_index));
  2780.   
  2781.   /* in the event we are running on an MP system, it would */
  2782.   /* probably be good to bind the soaker processes to specific */
  2783.   /* processors. I *think* this is the most reasonable thing to */
  2784.   /* do, and would be closes to simulating the information we get */
  2785.   /* on HP-UX with pstat. I could put all the system-specific code */
  2786.   /* here, but will "abstract it into another routine to keep this */
  2787.   /* area more readable. I'll probably do the same thine with the */
  2788.   /* "low pri code" raj 10/95 */
  2789.   
  2790.   /* NOTE. I do *NOT* think it would be appropriate for the actual */
  2791.   /* test processes to be bound to a  particular processor - that */
  2792.   /* is something that should be left up to the operating system. */
  2793.   
  2794.   bind_to_processor(child_index);
  2795.   
  2796.   for (*my_counter_ptr = 0L;
  2797.        ;
  2798.        (*my_counter_ptr)++) {
  2799.     if (!(*lib_base_pointer % 1)) {
  2800.       /* every once and again, make sure that our process priority is */
  2801.       /* nice and low. also, by making system calls, it may be easier */
  2802.       /* for us to be pre-empted by something that needs to do useful */
  2803.       /* work - like the thread of execution actually sending and */
  2804.       /* receiveing data across the network :) */
  2805. #ifdef _AIX
  2806.       int pid,prio;
  2807.  
  2808.       prio = PRIORITY;
  2809.       pid = getpid();
  2810.       /* if you are not root, this call will return EPERM - why one */
  2811.       /* cannot change one's own priority to  lower value is beyond */
  2812.       /* me. raj 2/26/96 */  
  2813.       setpri(pid, prio);
  2814. #else /* _AIX */
  2815. #ifdef __sgi
  2816.       int pid,prio;
  2817.  
  2818.       prio = PRIORITY;
  2819.       pid = getpid();
  2820.       schedctl(NDPRI, pid, prio);
  2821.       sginap(0);
  2822. #else /* __sgi */
  2823. #ifdef WIN32
  2824.       SetThreadPriority(GetCurrentThread(),THREAD_PRIORITY_IDLE);
  2825. #else /* WIN32 */
  2826. #ifdef __sun
  2827. #include <sys/types.h>
  2828. #include <sys/priocntl.h>
  2829. #include <sys/rtpriocntl.h>
  2830. #include <sys/tspriocntl.h>
  2831.       /* I would *really* like to know how to use priocntl to make the */
  2832.       /* priority low for this looper process. however, either my mind */
  2833.       /* is addled, or the manpage in section two for priocntl is not */
  2834.       /* terribly helpful - for one, it has no examples :( so, if you */
  2835.       /* can help, I'd love to hear from you. in the meantime, we will */
  2836.       /* rely on nice(39). raj 2/26/96 */
  2837.       nice(39);
  2838. #else /* __sun */
  2839.       nice(39);
  2840. #endif /* __sun */
  2841. #endif /* WIN32 */
  2842. #endif /* __sgi */
  2843. #endif /* _AIX */
  2844.     }
  2845.   }
  2846. }
  2847.  
  2848.  
  2849.  
  2850.  /* this routine will start all the looper processes or threads for */
  2851.  /* measuring CPU utilization. */
  2852.  
  2853. void
  2854. start_looper_processes()
  2855. {
  2856.  
  2857.   unsigned int  
  2858.     i,
  2859.     file_size;
  2860.   
  2861.   /* we want at least two pages for each processor. the */
  2862.   /* child for any one processor will write to the first of his two */
  2863.   /* pages, and the second page will be a buffer in case there is page */
  2864.   /* prefetching. if your system pre-fetches more than a single page, */
  2865.   /* well, you'll have to modify this or live with it :( raj 4/95 */
  2866.  
  2867.   file_size = ((NETPERF_PAGE_SIZE * PAGES_PER_CHILD) * 
  2868.            lib_num_loc_cpus);
  2869.   
  2870. #ifndef WIN32
  2871.  
  2872.   /* we we are not using WINDOWS NT (or 95 actually :), then we want */
  2873.   /* to create a memory mapped region so we can see all the counting */
  2874.   /* rates of the loopers */
  2875.  
  2876.   lib_idle_fd = open("/tmp/netperf_cpu",O_RDWR | O_CREAT | O_EXCL);
  2877.   
  2878.   if (lib_idle_fd == -1) {
  2879.     fprintf(where,"create_looper: file creation; errno %d\n",errno);
  2880.     fflush(where);
  2881.     exit(1);
  2882.   }
  2883.   
  2884.   if (chmod("/tmp/netperf_cpu",0644) == -1) {
  2885.     fprintf(where,"create_looper: chmod; errno %d\n",errno);
  2886.     fflush(where);
  2887.     exit(1);
  2888.   }
  2889.   
  2890.   /* with the file descriptor in place, lets be sure that the file is */
  2891.   /* large enough. */
  2892.   
  2893.   if (truncate("/tmp/netperf_cpu",file_size) == -1) {
  2894.     fprintf(where,"create_looper: truncate: errno %d\n",errno);
  2895.     fflush(where);
  2896.     exit(1);
  2897.   }
  2898.   
  2899.   /* the file should be large enough now, so we can mmap it */
  2900.   
  2901.   /* if the system does not have MAP_VARIABLE, just define it to */
  2902.   /* be zero. it is only used/needed on HP-UX (?) raj 4/95 */
  2903. #ifndef MAP_VARIABLE
  2904. #define MAP_VARIABLE 0x0000
  2905. #endif /* MAP_VARIABLE */
  2906. #ifndef MAP_FILE
  2907. #define MAP_FILE 0x0000
  2908. #endif /* MAP_FILE */
  2909.   if ((lib_base_pointer = (long *)mmap(NULL,
  2910.                        file_size,
  2911.                        PROT_READ | PROT_WRITE,
  2912.                        MAP_FILE | MAP_SHARED | MAP_VARIABLE,
  2913.                        lib_idle_fd,
  2914.                        0)) == (long *)-1) {
  2915.     fprintf(where,"create_looper: mmap: errno %d\n",errno);
  2916.     fflush(where);
  2917.     exit(1);
  2918.   }
  2919.   
  2920.  
  2921.   if (debug > 1) {
  2922.     fprintf(where,"num CPUs %d, file_size %d, lib_base_pointer 0x%8.0lx\n",
  2923.         lib_num_loc_cpus,
  2924.         file_size,
  2925.         (unsigned long)lib_base_pointer);
  2926.     fflush(where);
  2927.   }
  2928.  
  2929.   /* we should have a valid base pointer. lets fork */
  2930.   
  2931.   for (i = 0; i < lib_num_loc_cpus; i++) {
  2932.     switch (lib_idle_pids[i] = fork()) {
  2933.     case -1:
  2934.       perror("netperf: fork");
  2935.       exit(1);
  2936.     case 0:
  2937.       /* we are the child. we could decide to exec some separate */
  2938.       /* program, but that doesn't really seem worthwhile - raj 4/95 */
  2939.  
  2940.       sit_and_spin(i);
  2941.  
  2942.       /* we should never really get here, but if we do, just exit(0) */
  2943.       exit(0);
  2944.       break;
  2945.     default:
  2946.       /* we must be the parent */
  2947.       lib_idle_address[i] = (long *) ((char *)lib_base_pointer + 
  2948.                       (NETPERF_PAGE_SIZE * 
  2949.                        PAGES_PER_CHILD * i));
  2950.       if (debug) {
  2951.     fprintf(where,"lib_idle_address[%d] is %8.8lx\n",
  2952.         i,
  2953.         (unsigned long)lib_idle_address[i]);
  2954.     fflush(where);
  2955.       }
  2956.     }
  2957.   }
  2958. #else
  2959.   /* we are compiled -DWIN32 */
  2960.   if ((lib_base_pointer = malloc(file_size)) == NULL) {
  2961.     fprintf(where,
  2962.         "create_looper_process could not malloc %d bytes\n",
  2963.         file_size);
  2964.     fflush(where);
  2965.     exit(1);
  2966.   }
  2967.  
  2968.   /* now, create all the threads */
  2969.   for(i = 0; i < lib_num_loc_cpus; i++) {
  2970.     long place_holder;
  2971.     if ((lib_idle_pids[i] = CreateThread(0,
  2972.                      0,
  2973.                      (LPTHREAD_START_ROUTINE)sit_and_spin,
  2974.                      (LPVOID)i,
  2975.                      0,
  2976.                      &place_holder)) == NULL ) {
  2977.       fprintf(where,
  2978.           "create_looper_process: CreateThread failled\n");
  2979.       fflush(where);
  2980.       /* I wonder if I need to look for other threads to kill? */
  2981.       exit(1);
  2982.     }
  2983.     lib_idle_address[i] = (long *) ((char *)lib_base_pointer + 
  2984.                     (NETPERF_PAGE_SIZE * 
  2985.                      PAGES_PER_CHILD * i));
  2986.     if (debug) {
  2987.       fprintf(where,"lib_idle_address[%d] is %8.8lx\n",
  2988.           i,
  2989.           (unsigned long)lib_idle_address[i]);
  2990.       fflush(where);
  2991.     }
  2992.   }
  2993. #endif /* WIN32 */
  2994.  
  2995.   /* we need to have the looper processes settled-in before we do */
  2996.   /* anything with them, so lets sleep for say 30 seconds. raj 4/95 */
  2997.  
  2998.   sleep(30);
  2999. }
  3000.  
  3001. #endif /* USE_LOOPER */
  3002.  
  3003.  
  3004. float
  3005. calibrate_local_cpu(local_cpu_rate)
  3006.      float    local_cpu_rate;
  3007. {
  3008.   
  3009.   lib_num_loc_cpus = get_num_cpus();
  3010.  
  3011.   lib_use_idle = 0;
  3012. #ifdef USE_LOOPER
  3013.   /* we want to get the looper processes going */
  3014.   start_looper_processes();
  3015.   lib_use_idle = 1;
  3016. #endif /* USE_LOOPER */
  3017.  
  3018.   if (local_cpu_rate > 0) {
  3019.     /* The user think that he knows what the cpu rate is. We assume */
  3020.     /* that all the processors of an MP system are essentially the */
  3021.     /* same - for this reason we do not have a per processor maxrate. */
  3022.     /* if the machine has processors which are different in */
  3023.     /* performance, the CPU utilization will be skewed. raj 4/95 */
  3024.     lib_local_maxrate = local_cpu_rate;
  3025.   }
  3026.   else {
  3027.     /* if neither USE_LOOPER nor USE_PSTAT are defined, we return a */
  3028.     /* 0.0 to indicate that times or getrusage should be used. raj */
  3029.     /* 4/95 */
  3030.     lib_local_maxrate = (float)0.0;
  3031. #ifdef USE_LOOPER    
  3032.     lib_local_maxrate = calibrate_looper(4,10);
  3033. #endif
  3034. #ifdef USE_PSTAT
  3035. #ifdef PSTAT_IPCINFO
  3036.     /* one version of pstat needs calibration */
  3037.     lib_local_maxrate = calibrate_pstat(4,10);
  3038. #endif /* PSTAT_IPCINFO */
  3039. #endif /* USE_PSTAT */
  3040.   }
  3041.   return lib_local_maxrate;
  3042. }
  3043.  
  3044.  
  3045. float
  3046. calibrate_remote_cpu()
  3047. {
  3048.   float    remrate;
  3049.  
  3050.   netperf_request.content.request_type = CPU_CALIBRATE;
  3051.   send_request();
  3052.   /* we know that calibration will last at least 40 seconds, so go to */
  3053.   /* sleep for that long so the 60 second select in recv_response will */
  3054.   /* not pop. raj 7/95 */
  3055.   sleep(40);
  3056.   recv_response();
  3057.   if (netperf_response.content.serv_errno) {
  3058.     /* initially, silently ignore remote errors and pass */
  3059.     /* back a zero to the caller this should allow us to */
  3060.     /* mix rev 1.0 and rev 1.1 netperfs... */
  3061.     return((float)0.0);
  3062.   }
  3063.   else {
  3064.     /* the rate is the first word of the test_specific data */
  3065.     bcopy((char *)netperf_response.content.test_specific_data,
  3066.       (char *)&remrate,
  3067.       sizeof(remrate));
  3068. /*    remrate = (float) netperf_response.content.test_specific_data[0]; */
  3069.     return(remrate);
  3070.   }    
  3071. }
  3072.  
  3073. int
  3074. msec_sleep( msecs )
  3075.      int msecs;
  3076. {
  3077.  
  3078. #ifdef WIN32
  3079.   int        rval ;
  3080. #endif /* WIN32 */
  3081.  
  3082.   struct timeval interval;
  3083.  
  3084.   interval.tv_sec = msecs / 1000;
  3085.   interval.tv_usec = (msecs - (msecs/1000) *1000) * 1000;
  3086. #ifdef WIN32
  3087.   if (rval = select(0,
  3088. #else
  3089.   if (select(0,
  3090. #endif /* WIN32 */
  3091.          0,
  3092.          0,
  3093.          0,
  3094.          &interval)) {
  3095. #ifdef WIN32
  3096.     if ( rval == SOCKET_ERROR && WSAGetLastError() == WSAEINTR ) {
  3097. #else
  3098.     if (errno == EINTR) {
  3099. #endif /* WIN32 */
  3100.       return(1);
  3101.     }
  3102.     perror("msec_sleep: select");
  3103.     exit(1);
  3104.   }
  3105.   return(0);
  3106. }
  3107.  
  3108. #ifdef HISTOGRAM
  3109. /* hist.c
  3110.  
  3111.    Given a time difference in microseconds, increment one of 61
  3112.    different buckets: 
  3113.    
  3114.    0 - 9 in increments of 100 usecs
  3115.    1 - 9 in increments of 1 msec
  3116.    1 - 9 in increments of 10 msecs
  3117.    1 - 9 in increments of 100 msecs
  3118.    1 - 9 in increments of 1 sec
  3119.    1 - 9 in increments of 10 sec
  3120.    > 100 secs
  3121.    
  3122.    This will allow any time to be recorded to within an accuracy of
  3123.    10%, and provides a compact  representation for capturing the
  3124.    distribution of a large number of time differences (e.g.
  3125.    request-response latencies).
  3126.    
  3127.    Colin Low  10/6/93
  3128. */
  3129.  
  3130. /* #include "sys.h" */
  3131.  
  3132. /*#define HIST_TEST*/
  3133.  
  3134. HIST HIST_new(void){
  3135.    HIST h;
  3136.    if((h = (HIST) malloc(sizeof(struct histogram_struct))) == NULL) {
  3137.      perror("HIST_new - malloc failed");
  3138.      exit(1);
  3139.    }
  3140.    HIST_clear(h);
  3141.    return h;
  3142. }
  3143.  
  3144. void HIST_clear(HIST h){
  3145.    int i;
  3146.    for(i = 0; i < 10; i++){
  3147.       h->tenth_msec[i] = 0;
  3148.       h->unit_msec[i] = 0;
  3149.       h->ten_msec[i] = 0;
  3150.       h->hundred_msec[i] = 0;
  3151.       h->unit_sec[i] = 0;
  3152.       h->ten_sec[i] = 0;
  3153.    }
  3154.    h->ridiculous = 0;
  3155.    h->total = 0;
  3156. }
  3157.  
  3158. void HIST_add(register HIST h, int time_delta){
  3159.    register int val;
  3160.    h->total++;
  3161.    val = time_delta/100;
  3162.    if(val <= 9) h->tenth_msec[val]++;
  3163.    else {
  3164.       val = val/10;
  3165.       if(val <= 9) h->unit_msec[val]++;
  3166.       else {
  3167.          val = val/10;
  3168.          if(val <= 9) h->ten_msec[val]++;
  3169.          else {
  3170.             val = val/10;
  3171.             if(val <= 9) h->hundred_msec[val]++;
  3172.             else {
  3173.                val = val/10;
  3174.                if(val <= 9) h->unit_sec[val]++;
  3175.                else {
  3176.                    val = val/10;
  3177.                    if(val <= 9) h->ten_sec[val]++;
  3178.                    else h->ridiculous++;
  3179.                }
  3180.             }
  3181.          }
  3182.       }
  3183.    }
  3184. }
  3185.  
  3186. #define RB_printf printf
  3187.  
  3188. void output_row(FILE *fd, char *title, int *row){
  3189.    register int i;
  3190.    RB_printf("%s", title);
  3191.    for(i = 0; i < 10; i++) RB_printf(": %4d", row[i]);
  3192.    RB_printf("\n");
  3193. }
  3194.  
  3195.  
  3196. void HIST_report(HIST h){
  3197.    output_row(stdout, "TENTH_MSEC    ", h->tenth_msec);
  3198.    output_row(stdout, "UNIT_MSEC     ", h->unit_msec);
  3199.    output_row(stdout, "TEN_MSEC      ", h->ten_msec);
  3200.    output_row(stdout, "HUNDRED_MSEC  ", h->hundred_msec);
  3201.    output_row(stdout, "UNIT_SEC      ", h->unit_sec);
  3202.    output_row(stdout, "TEN_SEC       ", h->ten_sec);
  3203.    RB_printf(">100_SECS: %d\n", h->ridiculous);
  3204.    RB_printf("HIST_TOTAL:      %d\n", h->total);
  3205. }
  3206.  
  3207.  /* return the difference (in micro seconds) between two timeval */
  3208.  /* timestamps */
  3209. int
  3210. delta_micro(struct timeval *begin,struct timeval *end)
  3211.  
  3212. {
  3213.  
  3214.   int usecs, secs;
  3215.  
  3216.   if (end->tv_usec < begin->tv_usec) {
  3217.     /* borrow a second from the tv_sec */
  3218.     end->tv_usec += 1000000;
  3219.     end->tv_sec--;
  3220.   }
  3221.   usecs = end->tv_usec - begin->tv_usec;
  3222.   secs  = end->tv_sec - begin->tv_sec;
  3223.  
  3224.   usecs += (secs * 1000000);
  3225.  
  3226.   return(usecs);
  3227.  
  3228. }
  3229.  
  3230. #endif /* HISTOGRAM */
  3231.  
  3232. #ifdef DO_DLPI
  3233.  
  3234. int
  3235. put_control(fd, len, pri, ack)
  3236.      int fd, len, pri, ack;
  3237. {
  3238.   int error;
  3239.   int flags = 0;
  3240.   dl_error_ack_t *err_ack = (dl_error_ack_t *)control_data;
  3241.  
  3242.   control_message.len = len;
  3243.  
  3244.   if ((error = putmsg(fd, &control_message, 0, pri)) < 0 ) {
  3245.     fprintf(where,"put_control: putmsg error %d\n",error);
  3246.     fflush(where);
  3247.     return(-1);
  3248.   }
  3249.   if ((error = getmsg(fd, &control_message, 0, &flags)) < 0) {
  3250.     fprintf(where,"put_control: getsmg error %d\n",error);
  3251.     fflush(where);
  3252.     return(-1);
  3253.   }
  3254.   if (err_ack->dl_primitive != ack) {
  3255.     fprintf(where,"put_control: acknowledgement error wanted %u got %u \n",
  3256.         ack,err_ack->dl_primitive);
  3257.     if (err_ack->dl_primitive == DL_ERROR_ACK) {
  3258.       fprintf(where,"             dl_error_primitive: %u\n",
  3259.           err_ack->dl_error_primitive);
  3260.       fprintf(where,"             dl_errno:           %u\n",
  3261.           err_ack->dl_errno);
  3262.       fprintf(where,"             dl_unix_errno       %u\n",
  3263.           err_ack->dl_unix_errno);
  3264.     }
  3265.     fflush(where);
  3266.     return(-1);
  3267.   }
  3268.  
  3269.   return(0);
  3270. }
  3271.     
  3272. int
  3273. dl_open(devfile,ppa)
  3274.      char devfile[];
  3275.      int ppa;
  3276.      
  3277. {
  3278.   int fd;
  3279.   dl_attach_req_t *attach_req = (dl_attach_req_t *)control_data;
  3280.  
  3281.   if ((fd = open(devfile, O_RDWR)) == -1) {
  3282.     fprintf(where,"netperf: dl_open: open of %s failed, errno = %d\n",
  3283.         devfile,
  3284.         errno);
  3285.     return(-1);
  3286.   }
  3287.  
  3288.   attach_req->dl_primitive = DL_ATTACH_REQ;
  3289.   attach_req->dl_ppa = ppa;
  3290.  
  3291.   if (put_control(fd, sizeof(dl_attach_req_t), 0, DL_OK_ACK) < 0) {
  3292.     fprintf(where,
  3293.         "netperf: dl_open: could not send control message, errno = %d\n",
  3294.         errno);
  3295.     return(-1);
  3296.   }
  3297.   return(fd);
  3298. }
  3299.  
  3300. int
  3301. dl_bind(fd, sap, mode, dlsap_ptr, dlsap_len)
  3302.      int fd, sap, mode;
  3303.      char *dlsap_ptr;
  3304.      int *dlsap_len;
  3305. {
  3306.   dl_bind_req_t *bind_req = (dl_bind_req_t *)control_data;
  3307.   dl_bind_ack_t *bind_ack = (dl_bind_ack_t *)control_data;
  3308.  
  3309.   bind_req->dl_primitive = DL_BIND_REQ;
  3310.   bind_req->dl_sap = sap;
  3311.   bind_req->dl_max_conind = 1;
  3312.   bind_req->dl_service_mode = mode;
  3313.   bind_req->dl_conn_mgmt = 0;
  3314.   bind_req->dl_xidtest_flg = 0;
  3315.  
  3316.   if (put_control(fd, sizeof(dl_bind_req_t), 0, DL_BIND_ACK) < 0) {
  3317.     fprintf(where,
  3318.         "netperf: dl_bind: could not send control message, errno = %d\n",
  3319.         errno);
  3320.     return(-1);
  3321.   }
  3322.  
  3323.   /* at this point, the control_data portion of the control message */
  3324.   /* structure should contain a DL_BIND_ACK, which will have a full */
  3325.   /* DLSAP in it. we want to extract this and pass it up so that    */
  3326.   /* it can be passed around. */
  3327.   if (*dlsap_len >= bind_ack->dl_addr_length) {
  3328.     bcopy((char *)bind_ack+bind_ack->dl_addr_offset,
  3329.           dlsap_ptr,
  3330.           bind_ack->dl_addr_length);
  3331.     *dlsap_len = bind_ack->dl_addr_length;
  3332.     return(0);
  3333.   }
  3334.   else { 
  3335.     return (-1); 
  3336.   }
  3337. }
  3338.  
  3339. int
  3340. dl_connect(fd, rem_addr, rem_addr_len)
  3341.      int fd;
  3342.      unsigned char *rem_addr;
  3343.      int rem_addr_len;
  3344. {
  3345.   dl_connect_req_t *connection_req = (dl_connect_req_t *)control_data;
  3346.   dl_connect_con_t *connection_con = (dl_connect_con_t *)control_data;
  3347.   struct pollfd pinfo;
  3348.  
  3349.   int flags = 0;
  3350.  
  3351.   /* this is here on the off chance that we really want some data */
  3352.   u_long data_area[512];
  3353.   struct strbuf data_message;
  3354.  
  3355.   int error;
  3356.  
  3357.   data_message.maxlen = 2048;
  3358.   data_message.len = 0;
  3359.   data_message.buf = (char *)data_area;
  3360.  
  3361.   connection_req->dl_primitive = DL_CONNECT_REQ;
  3362.   connection_req->dl_dest_addr_length = rem_addr_len;
  3363.   connection_req->dl_dest_addr_offset = sizeof(dl_connect_req_t);
  3364.   connection_req->dl_qos_length = 0;
  3365.   connection_req->dl_qos_offset = 0;
  3366.   bcopy (rem_addr, 
  3367.      (unsigned char *)control_data + sizeof(dl_connect_req_t),
  3368.      rem_addr_len);
  3369.  
  3370.   /* well, I would call the put_control routine here, but the sequence */
  3371.   /* of connection stuff with DLPI is a bit screwey with all this */
  3372.   /* message passing - Toto, I don't think were in Berkeley anymore. */
  3373.  
  3374.   control_message.len = sizeof(dl_connect_req_t) + rem_addr_len;
  3375.   if ((error = putmsg(fd,&control_message,0,0)) !=0) {
  3376.     fprintf(where,"dl_connect: putmsg failure, errno = %d, error 0x%x \n",
  3377.             errno,error);
  3378.     fflush(where);
  3379.     return(-1);
  3380.   };
  3381.  
  3382.   pinfo.fd = fd;
  3383.   pinfo.events = POLLIN | POLLPRI;
  3384.   pinfo.revents = 0;
  3385.  
  3386.   if ((error = getmsg(fd,&control_message,&data_message,&flags)) != 0) {
  3387.     fprintf(where,"dl_connect: getmsg failure, errno = %d, error 0x%x \n",
  3388.             errno,error);
  3389.     fflush(where);
  3390.     return(-1);
  3391.   }
  3392.   while (control_data[0] == DL_TEST_CON) {
  3393.     /* i suppose we spin until we get an error, or a connection */
  3394.     /* indication */
  3395.     if((error = getmsg(fd,&control_message,&data_message,&flags)) !=0) {
  3396.        fprintf(where,"dl_connect: getmsg failure, errno = %d, error = 0x%x\n",
  3397.                errno,error);
  3398.        fflush(where);
  3399.        return(-1);
  3400.     }
  3401.   }
  3402.  
  3403.   /* we are out - it either worked or it didn't - which was it? */
  3404.   if (control_data[0] == DL_CONNECT_CON) {
  3405.     return(0);
  3406.   }
  3407.   else {
  3408.     return(-1);
  3409.   }
  3410. }
  3411.  
  3412. int
  3413. dl_accept(fd, rem_addr, rem_addr_len)
  3414.      int fd;
  3415.      unsigned char *rem_addr;
  3416.      int rem_addr_len;
  3417. {
  3418.   dl_connect_ind_t *connect_ind = (dl_connect_ind_t *)control_data;
  3419.   dl_connect_res_t *connect_res = (dl_connect_res_t *)control_data;
  3420.   int tmp_cor;
  3421.   int flags = 0;
  3422.  
  3423.   /* hang around and wait for a connection request */
  3424.   getmsg(fd,&control_message,0,&flags);
  3425.   while (control_data[0] != DL_CONNECT_IND) {
  3426.     getmsg(fd,&control_message,0,&flags);
  3427.   }
  3428.  
  3429.   /* now respond to the request. at some point, we may want to be sure */
  3430.   /* that the connection came from the correct station address, but */
  3431.   /* will assume that we do not have to worry about it just now. */
  3432.  
  3433.   tmp_cor = connect_ind->dl_correlation;
  3434.  
  3435.   connect_res->dl_primitive = DL_CONNECT_RES;
  3436.   connect_res->dl_correlation = tmp_cor;
  3437.   connect_res->dl_resp_token = 0;
  3438.   connect_res->dl_qos_length = 0;
  3439.   connect_res->dl_qos_offset = 0;
  3440.   connect_res->dl_growth = 0;
  3441.  
  3442.   return(put_control(fd, sizeof(dl_connect_res_t), 0, DL_OK_ACK));
  3443.  
  3444. }
  3445.  
  3446. int
  3447. dl_set_window(fd, window)
  3448.      int fd, window;
  3449. {
  3450.   return(0);
  3451. }
  3452.  
  3453. void
  3454. dl_stats(fd)
  3455.      int fd;
  3456. {
  3457. }
  3458.  
  3459. int
  3460. dl_send_disc(fd)
  3461.      int fd;
  3462. {
  3463. }
  3464.  
  3465. int
  3466. dl_recv_disc(fd)
  3467.      int fd;
  3468. {
  3469. }
  3470. #endif /* DO_DLPI*/
  3471.  
  3472.  /* these routines for confidence intervals are courtesy of IBM. They */
  3473.  /* have been modified slightly for more general usage beyond TCP/UDP */
  3474.  /* tests. raj 11/94 I would suspect that this code carries an IBM */
  3475.  /* copyright that is much the same as that for the original HP */
  3476.  /* netperf code */
  3477. int    confidence_iterations; /* for iterations */
  3478.  
  3479. double  
  3480.   result_confid=-10.0,
  3481.   loc_cpu_confid=-10.0,
  3482.   rem_cpu_confid=-10.0,
  3483.  
  3484.   measured_sum_result=0.0, 
  3485.   measured_square_sum_result=0.0,
  3486.   measured_mean_result=0.0, 
  3487.   measured_var_result=0.0, 
  3488.  
  3489.   measured_sum_local_cpu=0.0,
  3490.   measured_square_sum_local_cpu=0.0,
  3491.   measured_mean_local_cpu=0.0,
  3492.   measured_var_local_cpu=0.0, 
  3493.  
  3494.   measured_sum_remote_cpu=0.0,
  3495.   measured_square_sum_remote_cpu=0.0,
  3496.   measured_mean_remote_cpu=0.0,
  3497.   measured_var_remote_cpu=0.0, 
  3498.   
  3499.   measured_sum_local_service_demand=0.0,
  3500.   measured_square_sum_local_service_demand=0.0,
  3501.   measured_mean_local_service_demand=0.0,
  3502.   measured_var_local_service_demand=0.0,
  3503.  
  3504.   measured_sum_remote_service_demand=0.0,
  3505.   measured_square_sum_remote_service_demand=0.0,
  3506.   measured_mean_remote_service_demand=0.0,
  3507.   measured_var_remote_service_demand=0.0,
  3508.  
  3509.   measured_sum_local_time=0.0,
  3510.   measured_square_sum_local_time=0.0,
  3511.   measured_mean_local_time=0.0,
  3512.   measured_var_local_time=0.0,
  3513.  
  3514.   measured_mean_remote_time=0.0, 
  3515.   
  3516.   measured_fails,
  3517.   measured_local_results,
  3518.   confidence=-10.0;
  3519. /*  interval=0.1; */
  3520.  
  3521. /************************************************************************/
  3522. /*                                         */
  3523. /*         Constants for Confidence Intervals                          */
  3524. /*                                         */
  3525. /************************************************************************/
  3526. void 
  3527. init_stat()
  3528. {
  3529.     measured_sum_result=0.0;
  3530.     measured_square_sum_result=0.0;
  3531.     measured_mean_result=0.0;
  3532.     measured_var_result=0.0;
  3533.  
  3534.     measured_sum_local_cpu=0.0;
  3535.     measured_square_sum_local_cpu=0.0;
  3536.     measured_mean_local_cpu=0.0;
  3537.     measured_var_local_cpu=0.0;
  3538.  
  3539.     measured_sum_remote_cpu=0.0;
  3540.     measured_square_sum_remote_cpu=0.0;
  3541.     measured_mean_remote_cpu=0.0;
  3542.     measured_var_remote_cpu=0.0;
  3543.  
  3544.     measured_sum_local_service_demand=0.0;
  3545.     measured_square_sum_local_service_demand=0.0;
  3546.     measured_mean_local_service_demand=0.0;
  3547.     measured_var_local_service_demand=0.0;
  3548.  
  3549.     measured_sum_remote_service_demand=0.0;
  3550.     measured_square_sum_remote_service_demand=0.0;
  3551.     measured_mean_remote_service_demand=0.0;
  3552.     measured_var_remote_service_demand=0.0;
  3553.  
  3554.     measured_sum_local_time=0.0;
  3555.     measured_square_sum_local_time=0.0;
  3556.     measured_mean_local_time=0.0;
  3557.     measured_var_local_time=0.0;
  3558.  
  3559.     measured_mean_remote_time=0.0;
  3560.  
  3561.     measured_fails = 0.0;
  3562.     measured_local_results=0.0,
  3563.     confidence=-10.0;
  3564. }
  3565.  
  3566.  /* this routine does a simple table lookup for some statistical */
  3567.  /* function that I would remember if I stayed awake in my probstats */
  3568.  /* class... raj 11/94 */
  3569. double 
  3570. confid(level,freedom)
  3571. int    level;
  3572. int    freedom;
  3573. {
  3574. double  t99[35],t95[35];
  3575.  
  3576.    t95[1]=12.706;
  3577.    t95[2]= 4.303;
  3578.    t95[3]= 3.182;
  3579.    t95[4]= 2.776;
  3580.    t95[5]= 2.571;
  3581.    t95[6]= 2.447;
  3582.    t95[7]= 2.365;
  3583.    t95[8]= 2.306;
  3584.    t95[9]= 2.262;
  3585.    t95[10]= 2.228;
  3586.    t95[11]= 2.201;
  3587.    t95[12]= 2.179;
  3588.    t95[13]= 2.160;
  3589.    t95[14]= 2.145;
  3590.    t95[15]= 2.131;
  3591.    t95[16]= 2.120;
  3592.    t95[17]= 2.110;
  3593.    t95[18]= 2.101;
  3594.    t95[19]= 2.093;
  3595.    t95[20]= 2.086;
  3596.    t95[21]= 2.080;
  3597.    t95[22]= 2.074;
  3598.    t95[23]= 2.069;
  3599.    t95[24]= 2.064;
  3600.    t95[25]= 2.060;
  3601.    t95[26]= 2.056;
  3602.    t95[27]= 2.052;
  3603.    t95[28]= 2.048;
  3604.    t95[29]= 2.045;
  3605.    t95[30]= 2.042;
  3606.    
  3607.    t99[1]=63.657;
  3608.    t99[2]= 9.925;
  3609.    t99[3]= 5.841;
  3610.    t99[4]= 4.604;
  3611.    t99[5]= 4.032;
  3612.    t99[6]= 3.707;
  3613.    t99[7]= 3.499;
  3614.    t99[8]= 3.355;
  3615.    t99[9]= 3.250;
  3616.    t99[10]= 3.169;
  3617.    t99[11]= 3.106;
  3618.    t99[12]= 3.055;
  3619.    t99[13]= 3.012;
  3620.    t99[14]= 2.977;
  3621.    t99[15]= 2.947;
  3622.    t99[16]= 2.921;
  3623.    t99[17]= 2.898;
  3624.    t99[18]= 2.878;
  3625.    t99[19]= 2.861;
  3626.    t99[20]= 2.845;
  3627.    t99[21]= 2.831;
  3628.    t99[22]= 2.819;
  3629.    t99[23]= 2.807;
  3630.    t99[24]= 2.797;
  3631.    t99[25]= 2.787;
  3632.    t99[26]= 2.779;
  3633.    t99[27]= 2.771;
  3634.    t99[28]= 2.763;
  3635.    t99[29]= 2.756;
  3636.    t99[30]= 2.750;
  3637.    
  3638.    if(level==95){
  3639.        return(t95[freedom]);
  3640.    } else if(level==99){
  3641.         return(t99[freedom]);
  3642.    } else{
  3643.         return(0);
  3644.    }
  3645. }
  3646.  
  3647. void
  3648. calculate_confidence(confidence_iterations,
  3649.              time,
  3650.              result,
  3651.              loc_cpu,
  3652.              rem_cpu,
  3653.              loc_sd,
  3654.              rem_sd)
  3655. int    confidence_iterations;
  3656. float   time;
  3657. double    result;
  3658. float    loc_cpu;
  3659. float    rem_cpu;
  3660. float   loc_sd;
  3661. float   rem_sd;
  3662. {
  3663.  
  3664.   if (debug) {
  3665.     fprintf(where,
  3666.         "calculate_confidence: itr  %d; time %f; res  %f\n",
  3667.         confidence_iterations,
  3668.         time,
  3669.         result);
  3670.     fprintf(where,
  3671.         "                               lcpu %f; rcpu %f\n",
  3672.         loc_cpu,
  3673.         rem_cpu);
  3674.     fprintf(where,
  3675.         "                               lsdm %f; rsdm %f\n",
  3676.         loc_sd,
  3677.         rem_sd);
  3678.     fflush(where);
  3679.   }
  3680.  
  3681.   /* the test time */
  3682.   measured_sum_local_time        += 
  3683.     (double) time;
  3684.   measured_square_sum_local_time    += 
  3685.     (double) time*time;
  3686.   measured_mean_local_time        =  
  3687.     (double) measured_sum_local_time/confidence_iterations;
  3688.   measured_var_local_time        =  
  3689.     (double) measured_square_sum_local_time/confidence_iterations
  3690.       -measured_mean_local_time*measured_mean_local_time;
  3691.   
  3692.   /* the test result */
  3693.   measured_sum_result        += 
  3694.     (double) result;
  3695.   measured_square_sum_result    += 
  3696.     (double) result*result;
  3697.   measured_mean_result        =  
  3698.     (double) measured_sum_result/confidence_iterations;
  3699.   measured_var_result        =  
  3700.     (double) measured_square_sum_result/confidence_iterations
  3701.       -measured_mean_result*measured_mean_result;
  3702.  
  3703.   /* local cpu utilization */
  3704.   measured_sum_local_cpu    += 
  3705.     (double) loc_cpu;
  3706.   measured_square_sum_local_cpu    += 
  3707.     (double) loc_cpu*loc_cpu;
  3708.   measured_mean_local_cpu    = 
  3709.     (double) measured_sum_local_cpu/confidence_iterations;
  3710.   measured_var_local_cpu    = 
  3711.     (double) measured_square_sum_local_cpu/confidence_iterations
  3712.       -measured_mean_local_cpu*measured_mean_local_cpu;
  3713.  
  3714.   /* remote cpu util */
  3715.   measured_sum_remote_cpu    +=
  3716.     (double) rem_cpu;
  3717.   measured_square_sum_remote_cpu+=
  3718.     (double) rem_cpu*rem_cpu;
  3719.   measured_mean_remote_cpu    = 
  3720.     (double) measured_sum_remote_cpu/confidence_iterations;
  3721.   measured_var_remote_cpu    = 
  3722.     (double) measured_square_sum_remote_cpu/confidence_iterations
  3723.       -measured_mean_remote_cpu*measured_mean_remote_cpu;
  3724.  
  3725.   /* local service demand */
  3726.   measured_sum_local_service_demand    +=
  3727.     (double) loc_sd;
  3728.   measured_square_sum_local_service_demand+=
  3729.     (double) loc_sd*loc_sd;
  3730.   measured_mean_local_service_demand    = 
  3731.     (double) measured_sum_local_service_demand/confidence_iterations;
  3732.   measured_var_local_service_demand    = 
  3733.     (double) measured_square_sum_local_service_demand/confidence_iterations
  3734.       -measured_mean_local_service_demand*measured_mean_local_service_demand;
  3735.  
  3736.   /* remote service demand */
  3737.   measured_sum_remote_service_demand    +=
  3738.     (double) rem_sd;
  3739.   measured_square_sum_remote_service_demand+=
  3740.     (double) rem_sd*rem_sd;
  3741.   measured_mean_remote_service_demand    = 
  3742.     (double) measured_sum_remote_service_demand/confidence_iterations;
  3743.   measured_var_remote_service_demand    = 
  3744.     (double) measured_square_sum_remote_service_demand/confidence_iterations
  3745.       -measured_mean_remote_service_demand*measured_mean_remote_service_demand;
  3746.  
  3747.   if(confidence_iterations>1){ 
  3748.      result_confid= (double) interval - 
  3749.        2.0 * confid(confidence_level,confidence_iterations-1)* 
  3750.      sqrt(measured_var_result/(confidence_iterations-1.0)) / 
  3751.        measured_mean_result;
  3752.  
  3753.      loc_cpu_confid= (double) interval - 
  3754.        2.0 * confid(confidence_level,confidence_iterations-1)* 
  3755.      sqrt(measured_var_local_cpu/(confidence_iterations-1.0)) / 
  3756.        measured_mean_local_cpu;
  3757.  
  3758.      rem_cpu_confid= (double) interval - 
  3759.        2.0 * confid(confidence_level,confidence_iterations-1)*
  3760.      sqrt(measured_var_remote_cpu/(confidence_iterations-1.0)) / 
  3761.        measured_mean_remote_cpu;
  3762.  
  3763.      if(debug){
  3764.        printf("Conf_itvl %2d: results:%4.1f%% loc_cpu:%4.1f%% rem_cpu:%4.1f%%\n",
  3765.           confidence_iterations,
  3766.           (interval-result_confid)*100.0,
  3767.           (interval-loc_cpu_confid)*100.0,
  3768.           (interval-rem_cpu_confid)*100.0);
  3769.      }
  3770.  
  3771.      confidence = min(min(result_confid,loc_cpu_confid),rem_cpu_confid);
  3772.  
  3773.   }
  3774. }
  3775.  
  3776.  /* here ends the IBM code */
  3777.  
  3778. void
  3779. retrieve_confident_values(elapsed_time,
  3780.               thruput,
  3781.               local_cpu_utilization,
  3782.               remote_cpu_utilization,
  3783.               local_service_demand,
  3784.               remote_service_demand)
  3785.      float  *elapsed_time;
  3786.      double *thruput;
  3787.      float  *local_cpu_utilization;
  3788.      float  *remote_cpu_utilization;
  3789.      float  *local_service_demand;
  3790.      float  *remote_service_demand;
  3791.  
  3792. {
  3793.   *elapsed_time            = measured_mean_local_time;
  3794.   *thruput                 = measured_mean_result;
  3795.   *local_cpu_utilization   = measured_mean_local_cpu;
  3796.   *remote_cpu_utilization  = measured_mean_remote_cpu;
  3797.   *local_service_demand    = measured_mean_local_service_demand;
  3798.   *remote_service_demand   = measured_mean_remote_service_demand;
  3799. }
  3800.  
  3801.  /* display_confidence() is called when we could not achieve the */
  3802.  /* desirec confidence in the results. it will print the achieved */
  3803.  /* confidence to "where" raj 11/94 */
  3804. void
  3805. display_confidence()
  3806.  
  3807. {
  3808.   fprintf(where,
  3809.       "!!! WARNING\n");
  3810.   fprintf(where,
  3811.       "!!! Desired confidence was not achieved within ");
  3812.   fprintf(where,
  3813.       "the specified iterations.\n");
  3814.   fprintf(where,
  3815.       "!!! This implies that there was variability in ");
  3816.   fprintf(where,
  3817.       "the test environment that\n");
  3818.   fprintf(where,
  3819.       "!!! must be investigated before going further.\n");
  3820.   fprintf(where,
  3821.       "!!! Confidence intervals: Throughput      : %4.1f%%\n",
  3822.       100.0 * (interval - result_confid));
  3823.   fprintf(where,
  3824.       "!!!                       Local CPU util  : %4.1f%%\n",
  3825.       100.0 * (interval - loc_cpu_confid));
  3826.   fprintf(where,
  3827.       "!!!                       Remote CPU util : %4.1f%%\n\n",
  3828.       100.0 * (interval - rem_cpu_confid));
  3829. }
  3830.