httperf.c

一个WEB服务器的性能测试工具

	    {
	      errno = 0;
	      param.client.id = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		{
		  fprintf (stderr, "%s: bad client id (rest: `%s')\n",
			   prog_name, optarg);
		  exit (1);
		}

	      if (*end != '/')
		{
		  fprintf (stderr,
			   "%s: client id not followed by `/' (rest: `%s')\n",
			   prog_name, end);
		  exit (1);
		}
	      optarg = end + 1;

	      param.client.num_clients = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE
		  || param.client.id >= param.client.num_clients)
		{
		  fprintf (stderr, "%s: bad number of clients (rest: `%s')\n",
			   prog_name, optarg);
		  exit (1);
		}
	    }
	  else if (flag == &param.server)
	    param.server = optarg;
	  else if (flag == &param.server_name)
	    param.server_name = optarg;
#ifdef HAVE_SSL
	  else if (flag == &param.ssl_cipher_list)
	    param.ssl_cipher_list = optarg;
#endif
	  else if (flag == &param.uri)
	    param.uri = optarg;
	  else if (flag == &param.think_timeout)
	    {
	      errno = 0;
	      param.think_timeout = strtod (optarg, &end);
	      if (errno == ERANGE || end == optarg || *end)
		{
		  fprintf (stderr, "%s: illegal think timeout value %s\n",
			   prog_name, optarg);
		  exit (1);
		}
	    }
	  else if (flag == &param.timeout)
	    {
	      errno = 0;
	      param.timeout = strtod (optarg, &end);
	      if (errno == ERANGE || end == optarg || *end)
		{
		  fprintf (stderr, "%s: illegal connect timeout %s\n",
			   prog_name, optarg);
		  exit (1);
		}
	    }
	  else if (flag == &param.wlog)
	    {
	      gen[1] = &uri_wlog;	/* XXX fix me---somehow */

	      param.wlog.do_loop = (*optarg == 'y') || (*optarg == 'Y');
	      param.wlog.file = optarg + 2;
            }
	  else if (flag == &param.wsess)
	    {
	      num_gen = 2;		/* XXX fix me---somehow */
	      gen[0] = &wsess;

	      stat[num_stats++] = &session_stat;

	      errno = 0;
	      name = "bad number of sessions (1st param)";
	      param.wsess.num_sessions = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		goto bad_wsess_param;
	      optarg = end + 1;

	      name = "bad number of calls per session (2nd param)";
	      if (*end != ',')
		goto bad_wsess_param;
	      optarg = end + 1;

	      param.wsess.num_calls = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		goto bad_wsess_param;

	      name = "bad user think time (3rd param)";
	      if (*end != ',')
		goto bad_wsess_param;
	      optarg = end + 1;

	      param.wsess.think_time = strtod (optarg, &end);
	      if (end == optarg || errno == ERANGE 
		  || param.wsess.think_time < 0.0)
		goto bad_wsess_param;

	      name = "extraneous parameter";
	      if (*end)
		{
		bad_wsess_param:
		  fprintf (stderr, "%s: %s in --wsess arg (rest: `%s')",
			   prog_name, name, end);
		  if (errno)
		    fprintf (stderr, ": %s", strerror (errno));
		  fputc ('\n', stderr);
		  exit (1);
		}
	      session_workload = 1;
	    }
	  else if (flag == &param.wsesspage)
	    {
	      num_gen = 2;		/* XXX fix me---somehow */
	      gen[0] = &wsesspage;

	      stat[num_stats++] = &session_stat;

	      errno = 0;
	      name = "bad number of sessions (1st param)";
	      param.wsesspage.num_sessions = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		goto bad_wsesspage_param;
	      optarg = end + 1;

	      name = "bad number of user requests per session (2nd param)";
	      if (*end != ',')
		goto bad_wsesspage_param;
	      optarg = end + 1;

	      param.wsesspage.num_reqs = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		goto bad_wsesspage_param;

	      name = "bad user think time (3rd param)";
	      if (*end != ',')
		goto bad_wsesspage_param;
	      optarg = end + 1;

	      param.wsesspage.think_time = strtod (optarg, &end);
	      if (end == optarg || errno == ERANGE 
		  || param.wsesspage.think_time < 0.0)
		goto bad_wsesspage_param;

	      name = "extraneous parameter";
	      if (*end)
		{
		bad_wsesspage_param:
		  fprintf (stderr, "%s: %s in --wsesspage arg (rest: `%s')",
			   prog_name, name, end);
		  if (errno)
		    fprintf (stderr, ": %s", strerror (errno));
		  fputc ('\n', stderr);
		  exit (1);
		}
	      session_workload = 1;
	    }
	  else if (flag == &param.wsesslog)
	    {
	      num_gen = 1;		/* XXX fix me---somehow */
	      gen[0] = &wsesslog;

	      stat[num_stats++] = &session_stat;

	      errno = 0;
	      name = "bad number of sessions (1st param)";
	      param.wsesslog.num_sessions = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		goto bad_wsesslog_param;
	      optarg = end + 1;

	      name = "bad user think time (2nd param)";
	      if (*end != ',')
		goto bad_wsesslog_param;
	      optarg = end + 1;

	      param.wsesslog.think_time = strtod (optarg, &end);
	      if (end == optarg || errno == ERANGE 
		  || param.wsesslog.think_time < 0.0)
		goto bad_wsesslog_param;

	      name = "bad session filename (3rd param)";
	      if (*end != ',')
		goto bad_wsesslog_param;
	      optarg = end + 1;

	      /* simulate parsing of string */
	      param.wsesslog.file = optarg;
	      if ((end = strchr (optarg, ',')) == NULL)
		/* must be last param, position end at final \0 */
		end = optarg + strlen(optarg);
	      else
		/* terminate end of string */
		*end++ = '\0';
	      optarg = end;

	      name = "extraneous parameter";
	      if (*end)
		{
		bad_wsesslog_param:
		  fprintf (stderr, "%s: %s in --wsesslog arg (rest: `%s')",
			   prog_name, name, end);
 		  if (errno)
 		    fprintf (stderr, ": %s", strerror (errno));
 		  fputc ('\n', stderr);
		  exit (1);
		}
	      session_workload = 1;
	    }
	  else if (flag == &param.wset)
	    {
	      gen[1] = &uri_wset;	/* XXX fix me---somehow */

	      errno = 0;
	      name = "bad working set size (1st parameter)";
	      param.wset.num_files = strtoul (optarg, &end, 0);
	      if (end == optarg || errno == ERANGE)
		goto bad_wset_param;

	      name = "bad target miss rate (2nd parameter)";
	      if (*end != ',')
		goto bad_wset_param;
	      optarg = end + 1;

	      param.wset.target_miss_rate = strtod (optarg, &end);
	      if (end == optarg || errno == ERANGE
		  || param.wset.target_miss_rate < 0.0
		  || param.wset.target_miss_rate > 1.0)
		goto bad_wset_param;

	      name = "extraneous parameter";
	      if (*end)
		{
		bad_wset_param:
		  fprintf (stderr, "%s: %s in --wset arg (rest: `%s')",
			   prog_name, name, optarg);
		  if (errno)
		    fprintf (stderr, ": %s", strerror (errno));
		  fputc ('\n', stderr);
		  exit (1);
		}
	    }
	  break;

	case 'd':
#ifdef DEBUG
	  errno = 0;
	  debug_level = strtoul (optarg, &end, 10);
	  if (errno == ERANGE || end == optarg || *end)
	    {
	      fprintf (stderr, "%s: illegal debug level %s\n",
		       prog_name, optarg);
	      exit (1);
	    }
#else
	  fprintf (stderr, "%s: sorry, need to recompile with -DDEBUG on...\n",
		   prog_name);
#endif
	  break;

	case 'v':
	  ++verbose;
	  break;

	case 'V':
	  printf ("%s: httperf-"VERSION" compiled "__DATE__" with"
#ifndef DEBUG
		  "out"
#endif
		  " DEBUG with"
#ifndef TIME_SYSCALLS
		  "out"
#endif
		  " TIME_SYSCALLS.\n", prog_name);
	  break;

	case 'h':
	  usage ();
	  exit (0);

	case ':':
	  fprintf (stderr, "%s: parameter missing for option %s\n",
		   prog_name, longopts[longindex].name);
	  exit (1);

	case '?':
	  /* Invalid or ambiguous option name or extraneous parameter.
             getopt_long () already issued an explanation to the user,
             so all we do is call it quites.  */
	  exit (1);

	default:
	  fprintf (stderr,
		   "%s: getopt_long: unexpected value (%d)\n",
		   prog_name, ch);
	  exit (1);
	}
    }

#ifdef HAVE_SSL
  if (param.use_ssl)
    {
      char buf[1024];

      if (param.port < 0)
	param.port = 443;

      SSL_load_error_strings ();
      SSLeay_add_ssl_algorithms ();

      /* for some strange reason, SSLv23_client_method () doesn't work here */
      ssl_ctx = SSL_CTX_new (SSLv3_client_method ());
      if (!ssl_ctx)
	{
	  ERR_print_errors_fp (stderr);
	  exit (-1);
	}

      memset (buf, 0, sizeof (buf));
      RAND_seed (buf, sizeof (buf));
    }
#endif
  if (param.port < 0)
    param.port = 80;

  if (param.print_reply || param.print_request)
    stat[num_stats++] = &stats_print_reply;

  if (param.session_cookies)
    {
      if (!session_workload)
	{
	  fprintf (stderr, "%s: --session-cookie requires session-oriented "
		   "workload (e.g., --wsess)\n", prog_name);
	  exit (-1);
	}
      gen[num_gen++] = &sess_cookie;
    }

  if (param.additional_header || param.method)
    gen[num_gen++] = &misc;

  /* echo command invocation for logging purposes: */
  printf ("%s", prog_name);
  if (verbose) printf (" --verbose");
  switch (param.print_reply)
    {
    case 0:		break;
    case PRINT_HEADER:	printf (" --print-reply=header"); break;
    case PRINT_BODY:	printf (" --print-reply=body"); break;
    default:		printf (" --print-reply"); break;
    }
  switch (param.print_request)
    {
    case 0:		break;
    case PRINT_HEADER:	printf (" --print-request=header"); break;
    case PRINT_BODY:	printf (" --print-request=body"); break;
    default:		printf (" --print-request"); break;
    }
  if (param.hog) printf (" --hog");
  if (param.close_with_reset) printf (" --close-with-reset");
  if (param.think_timeout > 0) printf (" --think-timeout=%g",
				       param.think_timeout);
  if (param.timeout > 0) printf (" --timeout=%g", param.timeout);
  printf (" --client=%u/%u", param.client.id, param.client.num_clients);
  if (param.server) printf (" --server=%s", param.server);
  if (param.server_name) printf (" --server_name=%s", param.server_name);
  if (param.port) printf (" --port=%d", param.port);
  if (param.uri) printf (" --uri=%s", param.uri);
  if (param.failure_status) printf (" --failure-status=%u",
				    param.failure_status);
  if (param.http_version != 0x10001)
    printf (" --http-version=%u.%u", param.http_version >> 16,
	    param.http_version & 0xffff);
  if (param.max_conns)
    printf (" --max-connections=%u", param.max_conns);
  if (param.max_piped)
    printf (" --max-piped-calls=%u", param.max_piped);
  if (param.rate.rate_param > 0.0)
    {
      switch (param.rate.dist)
	{
	case DETERMINISTIC:
	  /* for backwards compatibility, continue to use --rate: */
	  printf (" --rate=%g", param.rate.rate_param);
	  break;

	case UNIFORM:
	  printf (" --period=u%g,%g",
		  param.rate.min_iat, param.rate.max_iat);
	  break;

	case EXPONENTIAL:
	  printf (" --period=e%g", param.rate.mean_iat);
	  break;

	default:
	  printf("--period=??");
	  break;
	}
    }
  printf (" --send-buffer=%d", param.send_buffer_size);
  if (param.retry_on_failure) printf (" --retry-on-failure");
  printf (" --recv-buffer=%d", param.recv_buffer_size);
  if (param.session_cookies) printf (" --session-cookies");
#ifdef HAVE_SSL
  if (param.use_ssl) printf (" --ssl");
  if (param.ssl_cipher_list)
    printf(" --ssl-ciphers=%s", param.ssl_cipher_list);
  if (!param.ssl_reuse) printf (" --ssl-no-reuse");
#endif
  if (param.additional_header)
    printf (" --add-header='%s'", param.additional_header);
  if (param.method) printf (" --method=%s", param.method);
  if (param.wsesslog.num_sessions)
    {
      /* This overrides any --wsess, --num-conns, --num-calls,
	 --burst-length and any uri generator */
      printf (" --wsesslog=%u,%.3f,%s", param.wsesslog.num_sessions,
	      param.wsesslog.think_time, param.wsesslog.file);
    }
  else if (param.wsesspage.num_sessions)
    {
      printf (" --wsesspage=%u,%u,%.3f", param.wsesspage.num_sessions,
	      param.wsesspage.num_reqs, param.wsesspage.think_time);
    }
  else
    {
      if (param.wsess.num_sessions)
	printf (" --wsess=%u,%u,%.3f", param.wsess.num_sessions,
		param.wsess.num_calls, param.wsess.think_time);
      else
	{
	  if (param.num_conns) printf (" --num-conns=%d", param.num_conns);
	  if (param.num_calls) printf (" --num-calls=%d",
				       param.num_calls);
	}
      if (param.burst_len != 1) printf (" --burst-length=%d", param.burst_len);
      if (param.wset.num_files) printf (" --wset=%u,%.3f",
					param.wset.num_files,
					param.wset.target_miss_rate);
    }
  printf ("\n");

  timer_init ();
  core_init ();

  signal (SIGINT, (void (*)()) core_exit);

  for (i = 0; i < num_stats; ++i)
    (*stat[i]->init)();
  for (i = 0; i < num_gen; ++i)
    (*gen[i]->init) ();

  /* Update `now'.  This is to keep things accurate even when some of
     the initialization routines take a long time to execute.  */
  timer_tick ();

  /* ensure that clients sample rates at different times: */
  t = (param.client.id + 1.0)*RATE_INTERVAL/param.client.num_clients;
  arg.l = 0;
  timer_schedule (perf_sample, arg, t);
  perf_sample_start = timer_now ();

  for (i = 0; i < num_gen; ++i)
    (*gen[i]->start) ();
  for (i = 0; i < num_stats; ++i)
    (*stat[i]->start)();

  getrusage (RUSAGE_SELF, &test_rusage_start);
  test_time_start = timer_now ();
  core_loop ();
  test_time_stop = timer_now ();
  getrusage (RUSAGE_SELF, &test_rusage_stop);

  for (i = 0; i < num_stats; ++i)
    (*stat[i]->stop)();
  for (i = 0; i < num_gen; ++i)
    (*gen[i]->stop) ();
  for (i = 0; i < num_stats; ++i)
    (*stat[i]->dump)();

  return 0;
}