One Level Up Top Level

src/weighttp.c - weighttp

Functions defined

Source code

  1. /*
  2. * weighttp - a lightweight and simple webserver benchmarking tool
  3. *
  4. * Author:
  5. *     Copyright (c) 2009-2011 Thomas Porzelt
  6. *
  7. * License:
  8. *     MIT, see COPYING file
  9. */

  11. #include "weighttp.h"

  13. extern int optind, optopt; /* getopt */

  15. ‌static void show_help(void) {
  16.     printf("weighttp <options> <url>\n");
  17.     printf("  -n num   number of requests    (mandatory)\n");
  18.     printf("  -t num   threadcount           (default: 1)\n");
  19.     printf("  -c num   concurrent clients    (default: 1)\n");
  20.     printf("  -k       keep alive            (default: no)\n");
  21.     printf("  -6       use ipv6              (default: no)\n");
  22.     printf("  -H str   add header to request\n");
  23.     printf("  -h       show help and exit\n");
  24.     printf("  -v       show version and exit\n\n");
  25.     printf("example: weighttpd -n 10000 -c 10 -t 2 -k -H \"User-Agent: foo\" localhost/index.html\n\n");
  26. }

  28. ‌static struct addrinfo *resolve_host(char *hostname, uint16_t port, uint8_t use_ipv6) {
  29.     int err;
  30.     char port_str[6];
  31.     struct addrinfo hints, *res, *res_first, *res_last;

  33.     memset(&hints, 0, sizeof(hints));
  34.     hints.ai_family = PF_UNSPEC;
  35.     hints.ai_socktype = SOCK_STREAM;

  37.     sprintf(port_str, "%d", port);

  39.     err = getaddrinfo(hostname, port_str, &hints, &res_first);

  41.     if (err) {
  42.         W_ERROR("could not resolve hostname: %s", hostname);
  43.         return NULL;
  44.     }

  46.     /* search for an ipv4 address, no ipv6 yet */
  47.     res_last = NULL;
  48.     for (res = res_first; res != NULL; res = res->ai_next) {
  49.         if (res->ai_family == AF_INET && !use_ipv6)
  50.             break;
  51.         else if (res->ai_family == AF_INET6 && use_ipv6)
  52.             break;

  54.         res_last = res;
  55.     }

  57.     if (!res) {
  58.         freeaddrinfo(res_first);
  59.         W_ERROR("could not resolve hostname: %s", hostname);
  60.         return NULL;
  61.     }

  63.     if (res != res_first) {
  64.         /* unlink from list and free rest */
  65.         res_last->ai_next = res->ai_next;
  66.         freeaddrinfo(res_first);
  67.         res->ai_next = NULL;
  68.     }

  70.     return res;
  71. }

  73. ‌static char *forge_request(char *url, char keep_alive, char **host, uint16_t *port, char **headers, uint8_t headers_num) {
  74.     char *c, *end;
  75.     char *req;
  76.     uint32_t len;
  77.     uint8_t i;
  78.     uint8_t have_user_agent, have_host;

  80.     *host = NULL;
  81.     *port = 0;

  83.     if (strncmp(url, "http://", 7) == 0)
  84.         url += 7;
  85.     else if (strncmp(url, "https://", 8) == 0) {
  86.         W_ERROR("%s", "no ssl support yet");
  87.         url += 8;
  88.         return NULL;
  89.     }

  91.     len = strlen(url);

  93.     if ((c = strchr(url, ':'))) {
  94.         /* found ':' => host:port */
  95.         *host = W_MALLOC(char, c - url + 1);
  96.         memcpy(*host, url, c - url);
  97.         (*host)[c - url] = '\0';

  99.         if ((end = strchr(c+1, '/'))) {
  100.             *end = '\0';
  101.             *port = atoi(c+1);
  102.             *end = '/';
  103.             url = end;
  104.         } else {
  105.             *port = atoi(c+1);
  106.             url += len;
  107.         }
  108.     } else {
  109.         *port = 80;

  111.         if ((c = strchr(url, '/'))) {
  112.             *host = W_MALLOC(char, c - url + 1);
  113.             memcpy(*host, url, c - url);
  114.             (*host)[c - url] = '\0';
  115.             url = c;
  116.         } else {
  117.             *host = W_MALLOC(char, len + 1);
  118.             memcpy(*host, url, len);
  119.             (*host)[len] = '\0';
  120.             url += len;
  121.         }
  122.     }

  124.     if (*port == 0) {
  125.         W_ERROR("%s", "could not parse url");
  126.         free(*host);
  127.         return NULL;
  128.     }

  130.     if (*url == '\0')
  131.         url = "/";

  133.     // total request size
  134.     len = strlen("GET HTTP/1.1\r\nConnection: keep-alive\r\n\r\n") + 1;
  135.     len += strlen(url);

  137.     have_user_agent = 0;
  138.     have_host = 0;
  139.     for (i = 0; i < headers_num; i++) {
  140.         len += strlen(headers[i]) + strlen("\r\n");
  141.         if (strncmp(headers[i], "User-Agent: ", sizeof("User-Agent: ")-1) == 0)
  142.             have_user_agent = 1;
  143.         if (strncasecmp(headers[i], "Host:", sizeof("Host:")-1) == 0)
  144.             have_host = 1;
  145.     }

  147.     if (!have_user_agent)
  148.         len += strlen("User-Agent: weighttp/" VERSION "\r\n");

  150.     if (!have_host) {
  151.         len += strlen("Host: :65536\r\n")-1;
  152.         len += strlen(*host);
  153.     }

  155.     req = W_MALLOC(char, len);

  157.     strcpy(req, "GET ");
  158.     strcat(req, url);
  159.     strcat(req, " HTTP/1.1\r\n");

  161.     if (!have_host) {
  162.         strcat(req, "Host: ");
  163.         strcat(req, *host);
  164.         if (*port != 80)
  165.             sprintf(req + strlen(req), ":%"PRIu16, *port);
  166.         strcat(req, "\r\n");
  167.     }

  169.     if (!have_user_agent)
  170.         sprintf(req + strlen(req), "User-Agent: weighttp/" VERSION "\r\n");

  172.     for (i = 0; i < headers_num; i++) {
  173.         strcat(req, headers[i]);
  174.         strcat(req, "\r\n");
  175.     }

  177.     if (keep_alive)
  178.         strcat(req, "Connection: keep-alive\r\n\r\n");
  179.     else
  180.         strcat(req, "Connection: close\r\n\r\n");

  182.     return req;
  183. }

  185. ‌uint64_t str_to_uint64(char *str) {
  186.     uint64_t i;

  188.     for (i = 0; *str; str++) {
  189.         if (*str < '0' || *str > '9')
  190.             return UINT64_MAX;

  192.         i *= 10;
  193.         i += *str - '0';
  194.     }

  196.     return i;
  197. }

  199. ‌int main(int argc, char *argv[]) {
  200.     Worker **workers;
  201.     pthread_t *threads;
  202.     int i;
  203.     char c;
  204.     int err;
  205.     struct ev_loop *loop;
  206.     ev_tstamp ts_start, ts_end;
  207.     Config config;
  208.     Worker *worker;
  209.     char *host;
  210.     uint16_t port;
  211.     uint8_t use_ipv6;
  212.     uint16_t rest_concur, rest_req;
  213.     Stats stats;
  214.     ev_tstamp duration;
  215.     int sec, millisec, microsec;
  216.     uint64_t rps;
  217.     uint64_t kbps;
  218.     char **headers;
  219.     uint8_t headers_num;

  221.     printf("weighttp - a lightweight and simple webserver benchmarking tool\n\n");

  223.     headers = NULL;
  224.     headers_num = 0;

  226.     /* default settings */
  227.     use_ipv6 = 0;
  228.     config.thread_count = 1;
  229.     config.concur_count = 1;
  230.     config.req_count = 0;
  231.     config.keep_alive = 0;

  233.     while ((c = getopt(argc, argv, ":hv6kn:t:c:H:")) != -1) {
  234.         switch (c) {
  235.             case 'h':
  236.                 show_help();
  237.                 return 0;
  238.             case 'v':
  239.                 printf("version:    " VERSION "\n");
  240.                 printf("build-date: " __DATE__ " " __TIME__ "\n\n");
  241.                 return 0;
  242.             case '6':
  243.                 use_ipv6 = 1;
  244.                 break;
  245.             case 'k':
  246.                 config.keep_alive = 1;
  247.                 break;
  248.             case 'n':
  249.                 config.req_count = str_to_uint64(optarg);
  250.                 break;
  251.             case 't':
  252.                 config.thread_count = atoi(optarg);
  253.                 break;
  254.             case 'c':
  255.                 config.concur_count = atoi(optarg);
  256.                 break;
  257.             case 'H':
  258.                 headers = W_REALLOC(headers, char*, headers_num+1);
  259.                 headers[headers_num] = optarg;
  260.                 headers_num++;
  261.                 break;
  262.             case '?':
  263.                 W_ERROR("unkown option: -%c", optopt);
  264.                 show_help();
  265.                 return 1;
  266.         }
  267.     }

  269.     if ((argc - optind) < 1) {
  270.         W_ERROR("%s", "missing url argument\n");
  271.         show_help();
  272.         return 1;
  273.     } else if ((argc - optind) > 1) {
  274.         W_ERROR("%s", "too many arguments\n");
  275.         show_help();
  276.         return 1;
  277.     }

  279.     /* check for sane arguments */
  280.     if (!config.thread_count) {
  281.         W_ERROR("%s", "thread count has to be > 0\n");
  282.         show_help();
  283.         return 1;
  284.     }
  285.     if (!config.concur_count) {
  286.         W_ERROR("%s", "number of concurrent clients has to be > 0\n");
  287.         show_help();
  288.         return 1;
  289.     }
  290.     if (!config.req_count) {
  291.         W_ERROR("%s", "number of requests has to be > 0\n");
  292.         show_help();
  293.         return 1;
  294.     }
  295.     if (config.req_count == UINT64_MAX || config.thread_count > config.req_count || config.thread_count > config.concur_count || config.concur_count > config.req_count) {
  296.         W_ERROR("%s", "insane arguments\n");
  297.         show_help();
  298.         return 1;
  299.     }


  302.     loop = ev_default_loop(0);
  303.     if (!loop) {
  304.         W_ERROR("%s", "could not initialize libev\n");
  305.         return 2;
  306.     }

  308.     if (NULL == (config.request = forge_request(argv[optind], config.keep_alive, &host, &port, headers, headers_num))) {
  309.         return 1;
  310.     }

  312.     config.request_size = strlen(config.request);
  313.     //printf("Request (%d):\n==========\n%s==========\n", config.request_size, config.request);
  314.     //printf("host: '%s', port: %d\n", host, port);

  316.     /* resolve hostname */
  317.     if(!(config.saddr = resolve_host(host, port, use_ipv6))) {
  318.         return 1;
  319.     }

  321.     /* spawn threads */
  322.     threads = W_MALLOC(pthread_t, config.thread_count);
  323.     workers = W_MALLOC(Worker*, config.thread_count);

  325.     rest_concur = config.concur_count % config.thread_count;
  326.     rest_req = config.req_count % config.thread_count;

  328.     printf("starting benchmark...\n");

  330.     memset(&stats, 0, sizeof(stats));
  331.     ts_start = ev_time();

  333.     for (i = 0; i < config.thread_count; i++) {
  334.         uint64_t reqs = config.req_count / config.thread_count;
  335.         uint16_t concur = config.concur_count / config.thread_count;
  336.         uint64_t diff;

  338.         if (rest_concur) {
  339.             diff = (i == config.thread_count) ? rest_concur : (rest_concur / config.thread_count);
  340.             diff = diff ? diff : 1;
  341.             concur += diff;
  342.             rest_concur -= diff;
  343.         }

  345.         if (rest_req) {
  346.             diff = (i == config.thread_count) ? rest_req : (rest_req / config.thread_count);
  347.             diff = diff ? diff : 1;
  348.             reqs += diff;
  349.             rest_req -= diff;
  350.         }
  351.         printf("spawning thread #%d: %"PRIu16" concurrent requests, %"PRIu64" total requests\n", i+1, concur, reqs);
  352.         workers[i] = worker_new(i+1, &config, concur, reqs);

  354.         if (!(workers[i])) {
  355.             W_ERROR("%s", "failed to allocate worker or client");
  356.             return 1;
  357.         }

  359.         err = pthread_create(&threads[i], NULL, worker_thread, (void*)workers[i]);

  361.         if (err != 0) {
  362.             W_ERROR("failed spawning thread (%d)", err);
  363.             return 2;
  364.         }
  365.     }

  367.     for (i = 0; i < config.thread_count; i++) {
  368.         err = pthread_join(threads[i], NULL);
  369.         worker = workers[i];

  371.         if (err != 0) {
  372.             W_ERROR("failed joining thread (%d)", err);
  373.             return 3;
  374.         }

  376.         stats.req_started += worker->stats.req_started;
  377.         stats.req_done += worker->stats.req_done;
  378.         stats.req_success += worker->stats.req_success;
  379.         stats.req_failed += worker->stats.req_failed;
  380.         stats.bytes_total += worker->stats.bytes_total;
  381.         stats.bytes_body += worker->stats.bytes_body;
  382.         stats.req_2xx += worker->stats.req_2xx;
  383.         stats.req_3xx += worker->stats.req_3xx;
  384.         stats.req_4xx += worker->stats.req_4xx;
  385.         stats.req_5xx += worker->stats.req_5xx;

  387.         worker_free(worker);
  388.     }

  390.     ts_end = ev_time();
  391.     duration = ts_end - ts_start;
  392.     sec = duration;
  393.     duration -= sec;
  394.     duration = duration * 1000;
  395.     millisec = duration;
  396.     duration -= millisec;
  397.     microsec = duration * 1000;
  398.     rps = stats.req_done / (ts_end - ts_start);
  399.     kbps = stats.bytes_total / (ts_end - ts_start) / 1024;
  400.     printf("\nfinished in %d sec, %d millisec and %d microsec, %"PRIu64" req/s, %"PRIu64" kbyte/s\n", sec, millisec, microsec, rps, kbps);
  401.     printf("requests: %"PRIu64" total, %"PRIu64" started, %"PRIu64" done, %"PRIu64" succeeded, %"PRIu64" failed, %"PRIu64" errored\n",
  402.         config.req_count, stats.req_started, stats.req_done, stats.req_success, stats.req_failed, stats.req_error
  403.     );
  404.     printf("status codes: %"PRIu64" 2xx, %"PRIu64" 3xx, %"PRIu64" 4xx, %"PRIu64" 5xx\n",
  405.         stats.req_2xx, stats.req_3xx, stats.req_4xx, stats.req_5xx
  406.     );
  407.     printf("traffic: %"PRIu64" bytes total, %"PRIu64" bytes http, %"PRIu64" bytes data\n",
  408.         stats.bytes_total,  stats.bytes_total - stats.bytes_body, stats.bytes_body
  409.     );

  411.     ev_default_destroy();

  413.     free(threads);
  414.     free(workers);
  415.     free(config.request);
  416.     free(host);
  417.     free(headers);
  418.     freeaddrinfo(config.saddr);

  420.     return 0;
  421. }

One Level Up Top Level