One Level Up Top Level

src/http/modules/ngx_http_upstream_least_time_module.c - nginx

Global variables defined

Data types defined

Functions defined

Macros defined

Source code


  2. /*
  3. * Copyright (C) Nginx, Inc.
  4. */


  7. #include <ngx_config.h>
  8. #include <ngx_core.h>
  9. #include <ngx_http.h>


  12. ‌#define NGX_HTTP_UPSTREAM_LT_HEADER     0
  13. ‌#define NGX_HTTP_UPSTREAM_LT_LAST_BYTE  1


  16. ‌typedef struct {
  17.     ngx_uint_t                         mode;
  18.     ngx_uint_t                         use_inflight;
  19.                                                 /* unsigned  use_inflight:1; */
  20. ‌} ngx_http_upstream_lt_conf_t;


  23. ‌typedef struct {
  24.     /* the round robin data must be first */
  25.     ngx_http_upstream_rr_peer_data_t   rrp;

  27.     ngx_http_upstream_lt_conf_t       *conf;
  28.     ngx_uint_t                         inflight;  /* unsigned  inflight:1; */
  29.     ngx_http_upstream_t               *upstream;
  30. ‌} ngx_http_upstream_lt_peer_data_t;


  33. static ngx_int_t ngx_http_upstream_init_least_time_peer(ngx_http_request_t *r,
  34.     ngx_http_upstream_srv_conf_t *us);
  35. static ngx_int_t ngx_http_upstream_get_least_time_peer(
  36.     ngx_peer_connection_t *pc, void *data);
  37. static ngx_uint_t ngx_http_upstream_least_time_eta(
  38.     ngx_http_upstream_lt_peer_data_t *ltp, ngx_http_upstream_rr_peer_t *peer);
  39. static void ngx_http_upstream_least_time_notify(ngx_peer_connection_t *pc,
  40.     void *data, ngx_uint_t type);
  41. static void ngx_http_upstream_least_time_inflight_done(
  42.     ngx_http_upstream_lt_peer_data_t *ltp, ngx_http_upstream_rr_peers_t *peers,
  43.     ngx_http_upstream_rr_peer_t *peer, ngx_msec_t last);
  44. static void ngx_http_upstream_free_least_time_peer(ngx_peer_connection_t *pc,
  45.     void *data, ngx_uint_t state);

  47. static void *ngx_http_upstream_least_time_create_conf(ngx_conf_t *cf);
  48. static char *ngx_http_upstream_least_time(ngx_conf_t *cf, ngx_command_t *cmd,
  49.     void *conf);


  52. ‌static ngx_conf_enum_t  ngx_http_upstream_least_time_mode[] = {
  53.     { ngx_string("header"), NGX_HTTP_UPSTREAM_LT_HEADER },
  54.     { ngx_string("last_byte"), NGX_HTTP_UPSTREAM_LT_LAST_BYTE },
  55.     { ngx_null_string, 0 }
  56. };


  59. ‌static ngx_command_t  ngx_http_upstream_least_time_commands[] = {

  61.     { ngx_string("least_time"),
  62.       NGX_HTTP_UPS_CONF|NGX_CONF_TAKE12,
  63.       ngx_http_upstream_least_time,
  64.       NGX_HTTP_SRV_CONF_OFFSET,
  65.       offsetof(ngx_http_upstream_lt_conf_t, mode),
  66.       &ngx_http_upstream_least_time_mode },

  68.       ngx_null_command
  69. };


  72. ‌static ngx_http_module_t  ngx_http_upstream_least_time_module_ctx = {
  73.     NULL,                                  /* preconfiguration */
  74.     NULL,                                  /* postconfiguration */

  76.     NULL,                                  /* create main configuration */
  77.     NULL,                                  /* init main configuration */

  79.     ngx_http_upstream_least_time_create_conf,
  80.                                            /* create server configuration */
  81.     NULL,                                  /* merge server configuration */

  83.     NULL,                                  /* create location configuration */
  84.     NULL                                   /* merge location configuration */
  85. };


  88. ‌ngx_module_t  ngx_http_upstream_least_time_module = {
  89.     NGX_MODULE_V1,
  90.     &ngx_http_upstream_least_time_module_ctx, /* module context */
  91.     ngx_http_upstream_least_time_commands, /* module directives */
  92.     NGX_HTTP_MODULE,                       /* module type */
  93.     NULL,                                  /* init master */
  94.     NULL,                                  /* init module */
  95.     NULL,                                  /* init process */
  96.     NULL,                                  /* init thread */
  97.     NULL,                                  /* exit thread */
  98.     NULL,                                  /* exit process */
  99.     NULL,                                  /* exit master */
  100.     NGX_MODULE_V1_PADDING
  101. };


  104. static ngx_int_t
  105. ‌ngx_http_upstream_init_least_time(ngx_conf_t *cf,
  106.     ngx_http_upstream_srv_conf_t *us)
  107. {
  108.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, cf->log, 0,
  109.                    "init least time");

  111.     if (ngx_http_upstream_init_round_robin(cf, us) != NGX_OK) {
  112.         return NGX_ERROR;
  113.     }

  115.     us->peer.init = ngx_http_upstream_init_least_time_peer;

  117.     return NGX_OK;
  118. }


  121. static ngx_int_t
  122. ‌ngx_http_upstream_init_least_time_peer(ngx_http_request_t *r,
  123.     ngx_http_upstream_srv_conf_t *us)
  124. {
  125.     ngx_http_upstream_lt_conf_t       *ltcf;
  126.     ngx_http_upstream_lt_peer_data_t  *ltp;

  128.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, r->connection->log, 0,
  129.                    "init least time peer");

  131.     ltp = ngx_pcalloc(r->pool, sizeof(ngx_http_upstream_lt_peer_data_t));
  132.     if (ltp == NULL) {
  133.         return NGX_ERROR;
  134.     }

  136.     r->upstream->peer.data = &ltp->rrp;

  138.     if (ngx_http_upstream_init_round_robin_peer(r, us) != NGX_OK) {
  139.         return NGX_ERROR;
  140.     }

  142.     r->upstream->peer.get = ngx_http_upstream_get_least_time_peer;
  143.     r->upstream->peer.free = ngx_http_upstream_free_least_time_peer;

  145.     ltp->upstream = r->upstream;

  147.     ltcf = ngx_http_conf_upstream_srv_conf(us,
  148.                                            ngx_http_upstream_least_time_module);

  150.     if (ltcf->use_inflight) {
  151.         r->upstream->peer.notify = ngx_http_upstream_least_time_notify;
  152.     }

  154.     ltp->conf = ltcf;

  156.     return NGX_OK;
  157. }


  160. static ngx_int_t
  161. ‌ngx_http_upstream_get_least_time_peer(ngx_peer_connection_t *pc, void *data)
  162. {
  163.     ngx_http_upstream_lt_peer_data_t *ltp = data;

  165.     time_t                             now;
  166.     uintptr_t                          m;
  167.     ngx_int_t                          rc, total;
  168.     ngx_uint_t                         i, n, p, many, eta, best_eta;
  169.     ngx_msec_t                         ift;
  170.     ngx_http_upstream_rr_peer_t       *peer, *best;
  171.     ngx_http_upstream_rr_peers_t      *peers;
  172.     ngx_http_upstream_rr_peer_data_t  *rrp;

  174.     ngx_log_debug1(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  175.                    "get least time peer, try: %ui", pc->tries);

  177.     rrp = &ltp->rrp;

  179.     if (rrp->peers->single) {
  180.         return ngx_http_upstream_get_round_robin_peer(pc, rrp);
  181.     }

  183.     pc->cached = 0;
  184.     pc->connection = NULL;

  186.     now = ngx_time();

  188.     peers = rrp->peers;

  190.     ngx_http_upstream_rr_peers_wlock(peers);

  192. #if (NGX_HTTP_UPSTREAM_ZONE)
  193.     if (peers->config && rrp->config != *peers->config) {
  194.         goto busy;
  195.     }
  196. #endif

  198.     best = NULL;
  199.     total = 0;

  201. #if (NGX_SUPPRESS_WARN)
  202.     many = 0;
  203.     p = 0;
  204.     best_eta = 0;
  205. #endif

  207. #if (NGX_HTTP_UPSTREAM_SID)
  208.     best = ngx_http_upstream_get_rr_peer_by_sid(rrp, pc->hint, &p, 0);

  210.     if (best) {
  211.         goto best_chosen;
  212.     }
  213. #endif

  215.     for (peer = peers->peer, i = 0;
  216.          peer;
  217.          peer = peer->next, i++)
  218.     {
  219.         n = i / (8 * sizeof(uintptr_t));
  220.         m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  222.         if (rrp->tried[n] & m) {
  223.             continue;
  224.         }

  226.         if (peer->down) {
  227.             continue;
  228.         }

  230.         if (peer->max_fails
  231.             && peer->fails >= peer->max_fails
  232.             && now - peer->checked <= peer->fail_timeout)
  233.         {
  234.             continue;
  235.         }

  237.         if (peer->max_conns && peer->conns >= peer->max_conns) {
  238.             continue;
  239.         }

  241.         if (peer->inflight_reqs > 0) {

  243.             ift = peer->inflight_last / peer->inflight_reqs
  244.                   + (ngx_current_msec - peer->inflight_reqs_changed);

  246.             ngx_http_upstream_response_time_avg(&peer->inflight_time, ift);
  247.         }

  249.         /*
  250.          * select peer with least estimated time of processing; if there are
  251.          * multiple peers with the same time, select based on round-robin
  252.          */

  254.         eta = ngx_http_upstream_least_time_eta(ltp, peer);

  256.         if (best == NULL
  257.             || eta * best->weight < best_eta * peer->weight)
  258.         {
  259.             best = peer;
  260.             best_eta = eta;
  261.             many = 0;
  262.             p = i;

  264.         } else if (eta * best->weight == best_eta * peer->weight) {
  265.             many = 1;
  266.         }
  267.     }

  269.     if (best == NULL) {
  270.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  271.                        "get least time peer, no peer found");

  273.         goto failed;
  274.     }

  276.     if (many) {
  277.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  278.                        "get least time peer, many");

  280.         for (peer = best, i = p;
  281.              peer;
  282.              peer = peer->next, i++)
  283.         {
  284.             n = i / (8 * sizeof(uintptr_t));
  285.             m = (uintptr_t) 1 << i % (8 * sizeof(uintptr_t));

  287.             if (rrp->tried[n] & m) {
  288.                 continue;
  289.             }

  291.             if (peer->down) {
  292.                 continue;
  293.             }

  295.             eta = ngx_http_upstream_least_time_eta(ltp, peer);

  297.             if (eta * best->weight != best_eta * peer->weight) {
  298.                 continue;
  299.             }

  301.             if (peer->max_fails
  302.                 && peer->fails >= peer->max_fails
  303.                 && now - peer->checked <= peer->fail_timeout)
  304.             {
  305.                 continue;
  306.             }

  308.             if (peer->max_conns && peer->conns >= peer->max_conns) {
  309.                 continue;
  310.             }

  312.             peer->current_weight += peer->effective_weight;
  313.             total += peer->effective_weight;

  315.             if (peer->effective_weight < peer->weight) {
  316.                 peer->effective_weight++;
  317.             }

  319.             if (peer->current_weight > best->current_weight) {
  320.                 best = peer;
  321.                 p = i;
  322.             }
  323.         }
  324.     }

  326.     best->current_weight -= total;

  328. #if (NGX_HTTP_UPSTREAM_SID)
  329. best_chosen:
  330. #endif

  332.     if (ltp->conf->use_inflight) {
  333.         if (best->inflight_reqs > 0) {
  334.             /* account time spent by inflight requests */
  335.             best->inflight_last +=
  336.                                (ngx_current_msec - best->inflight_reqs_changed)
  337.                                * best->inflight_reqs;
  338.         }

  340.         best->inflight_reqs_changed = ngx_current_msec;
  341.         best->inflight_reqs++;

  343.         ltp->inflight = 1;
  344.     }

  346.     if (now - best->checked > best->fail_timeout) {
  347.         best->checked = now;
  348.     }

  350.     pc->sockaddr = best->sockaddr;
  351.     pc->socklen = best->socklen;
  352.     pc->name = &best->name;

  354. #if (NGX_HTTP_UPSTREAM_SID)
  355.     pc->sid = &best->sid;
  356. #endif

  358.     best->conns++;

  360.     rrp->current = best;
  361.     ngx_http_upstream_rr_peer_ref(peers, best);

  363.     n = p / (8 * sizeof(uintptr_t));
  364.     m = (uintptr_t) 1 << p % (8 * sizeof(uintptr_t));

  366.     rrp->tried[n] |= m;

  368.     ngx_http_upstream_rr_peers_unlock(peers);

  370.     return NGX_OK;

  372. failed:

  374.     if (peers->next) {
  375.         ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0,
  376.                        "get least time peer, backup servers");

  378.         rrp->peers = peers->next;

  380.         n = (rrp->peers->number + (8 * sizeof(uintptr_t) - 1))
  381.                 / (8 * sizeof(uintptr_t));

  383.         for (i = 0; i < n; i++) {
  384.              rrp->tried[i] = 0;
  385.         }

  387.         ngx_http_upstream_rr_peers_unlock(peers);

  389.         rc = ngx_http_upstream_get_least_time_peer(pc, rrp);

  391.         if (rc != NGX_BUSY) {
  392.             return rc;
  393.         }

  395.         ngx_http_upstream_rr_peers_wlock(peers);
  396.     }

  398. #if (NGX_HTTP_UPSTREAM_ZONE)
  399. busy:
  400. #endif

  402.     ngx_http_upstream_rr_peers_unlock(peers);

  404.     pc->name = peers->name;

  406.     return NGX_BUSY;
  407. }


  410. static ngx_uint_t
  411. ‌ngx_http_upstream_least_time_eta(ngx_http_upstream_lt_peer_data_t *ltp,
  412.     ngx_http_upstream_rr_peer_t *peer)
  413. {
  414.     time_t      now;
  415.     ngx_msec_t  rt;

  417.     switch (ltp->conf->mode) {

  419.     case NGX_HTTP_UPSTREAM_LT_HEADER:
  420.         rt = peer->header_time;
  421.         break;

  423.     default: /* NGX_HTTP_UPSTREAM_LT_LAST_BYTE */
  424.         rt = peer->response_time;
  425.     }

  427.     now = ngx_time();

  429.     if (now - peer->checked > peer->fail_timeout) {
  430.         /*
  431.          * once in fail_timeout make response time of a peer 2 times
  432.          * lower to give chances to slow peers
  433.          */
  434.         rt >>= (now - peer->checked) / (peer->fail_timeout + 1);
  435.     }

  437.     if (peer->inflight_reqs > 0) {
  438.         /*
  439.          * average inflight time exceeding average response time indicates
  440.          * bad (low priority) peer
  441.          */
  442.         rt = ngx_max(rt, peer->inflight_time);
  443.     }

  445.     if (rt > 5000) {
  446.         /*
  447.          * consider peers with response time greater than max equally bad
  448.          * and thus fallback to least_conns
  449.          */
  450.         rt = 5000;

  452.     } else {
  453.         /*
  454.          * divide response times into clusters to allow round-robin for peers
  455.          * with close response times
  456.          */
  457.         rt += 20 - rt % 20;
  458.     }

  460.     /*
  461.      * estimated time peer has to spend to finish processing current requests
  462.      */
  463.     return rt * (1 + peer->conns);
  464. }


  467. static void
  468. ‌ngx_http_upstream_least_time_notify(ngx_peer_connection_t *pc, void *data,
  469.     ngx_uint_t type)
  470. {
  471.     ngx_http_upstream_lt_peer_data_t *ltp = data;

  473.     ngx_msec_t                         last, *metric;
  474.     ngx_http_upstream_t               *u;
  475.     ngx_http_upstream_rr_peer_t       *peer;
  476.     ngx_http_upstream_rr_peers_t      *peers;
  477.     ngx_http_upstream_rr_peer_data_t  *rrp;

  479.     rrp = &ltp->rrp;

  481.     peers = rrp->peers;
  482.     peer = rrp->current;

  484.     u = ltp->upstream;

  486.     /*
  487.      * Only update average time here if needed for balancing.
  488.      * Otherwise, it will be updated in peer.free().
  489.      */

  491.     switch (type) {

  493.     case NGX_HTTP_UPSTREAM_NOTIFY_HEADER:

  495.         if (ltp->conf->mode != NGX_HTTP_UPSTREAM_LT_HEADER) {
  496.             return;
  497.         }

  499.         last = u->state->header_time;
  500.         metric = &peer->header_time;
  501.         break;

  503.     default:
  504.         return;
  505.     }

  507.     ngx_http_upstream_rr_peers_rlock(peers);
  508.     ngx_http_upstream_rr_peer_lock(peers, peer);

  510.     ngx_http_upstream_response_time_avg(metric, last);

  512.     if (ltp->inflight) {
  513.         ngx_http_upstream_least_time_inflight_done(ltp, peers, peer, last);
  514.     }

  516.     ngx_http_upstream_rr_peer_unlock(peers, peer);
  517.     ngx_http_upstream_rr_peers_unlock(peers);
  518. }


  521. static void
  522. ‌ngx_http_upstream_least_time_inflight_done(
  523.     ngx_http_upstream_lt_peer_data_t *ltp, ngx_http_upstream_rr_peers_t *peers,
  524.     ngx_http_upstream_rr_peer_t *peer, ngx_msec_t last)
  525. {
  526.     if (peer->inflight_reqs == 1) {
  527.         /* no more inflight requests */
  528.         peer->inflight_last = 0;

  530.     } else {

  532.         /*
  533.          * account time spent by inflight requests and forget about
  534.          * request "completed" right now
  535.          */
  536.         peer->inflight_last += (ngx_current_msec - peer->inflight_reqs_changed)
  537.                                * peer->inflight_reqs - last;
  538.         peer->inflight_reqs_changed = ngx_current_msec;
  539.     }

  541.     peer->inflight_reqs--;
  542.     ltp->inflight = 0;
  543. }


  546. static void
  547. ‌ngx_http_upstream_free_least_time_peer(ngx_peer_connection_t *pc,
  548.     void *data, ngx_uint_t state)
  549. {
  550.     ngx_http_upstream_lt_peer_data_t *ltp = data;

  552.     ngx_http_upstream_t               *u;
  553.     ngx_http_upstream_rr_peer_t       *peer;
  554.     ngx_http_upstream_rr_peers_t      *peers;
  555.     ngx_http_upstream_rr_peer_data_t  *rrp;

  557.     ngx_log_debug0(NGX_LOG_DEBUG_HTTP, pc->log, 0, "free least time peer");

  559.     rrp = &ltp->rrp;
  560.     peers = rrp->peers;
  561.     peer = rrp->current;

  563.     u = ltp->upstream;

  565.     ngx_http_upstream_rr_peers_rlock(peers);
  566.     ngx_http_upstream_rr_peer_lock(peers, peer);

  568.     if (ltp->inflight) {
  569.         ngx_http_upstream_least_time_inflight_done(ltp, peers, peer,
  570.                                                    u->state->response_time);
  571.     }

  573.     /*
  574.      * only successful attempts are accounted to mitigate preferring
  575.      * of failing peers
  576.      */
  577.     if (state & (NGX_PEER_FAILED|NGX_PEER_NEXT)) {
  578.         goto done;
  579.     }

  581.     if (u->state->header_time == (ngx_msec_t) -1) {
  582.         goto done;
  583.     }

  585.     ngx_http_upstream_response_time_avg(&peer->response_time,
  586.                                         u->state->response_time);

  588.     if (ltp->conf->use_inflight
  589.         && ltp->conf->mode == NGX_HTTP_UPSTREAM_LT_HEADER)
  590.     {
  591.         goto done;
  592.     }

  594.     ngx_http_upstream_response_time_avg(&peer->header_time,
  595.                                         u->state->header_time);

  597. done:

  599.     ngx_http_upstream_free_round_robin_peer_locked(pc, rrp, state);
  600. }


  603. static void *
  604. ‌ngx_http_upstream_least_time_create_conf(ngx_conf_t *cf)
  605. {
  606.     ngx_http_upstream_lt_conf_t  *conf;

  608.     conf = ngx_pcalloc(cf->pool, sizeof(ngx_http_upstream_lt_conf_t));
  609.     if (conf == NULL) {
  610.         return NULL;
  611.     }

  613.     /*
  614.      * set by ngx_pcalloc():
  615.      *
  616.      *     conf->use_inflight = 0;
  617.      */

  619.     conf->mode = NGX_CONF_UNSET_UINT;

  621.     return conf;
  622. }


  625. static char *
  626. ‌ngx_http_upstream_least_time(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
  627. {
  628.     ngx_str_t                     *value;
  629.     ngx_http_upstream_lt_conf_t   *ltcf;
  630.     ngx_http_upstream_srv_conf_t  *uscf;

  632.     uscf = ngx_http_conf_get_module_srv_conf(cf, ngx_http_upstream_module);

  634.     if (uscf->peer.init_upstream) {
  635.         ngx_conf_log_error(NGX_LOG_WARN, cf, 0,
  636.                            "load balancing method redefined");
  637.     }

  639.     uscf->peer.init_upstream = ngx_http_upstream_init_least_time;

  641.     uscf->flags = NGX_HTTP_UPSTREAM_CREATE
  642.                   |NGX_HTTP_UPSTREAM_MODIFY
  643.                   |NGX_HTTP_UPSTREAM_WEIGHT
  644.                   |NGX_HTTP_UPSTREAM_MAX_CONNS
  645.                   |NGX_HTTP_UPSTREAM_MAX_FAILS
  646.                   |NGX_HTTP_UPSTREAM_FAIL_TIMEOUT
  647.                   |NGX_HTTP_UPSTREAM_DOWN
  648.                   |NGX_HTTP_UPSTREAM_BACKUP;

  650.     if (cf->args->nelts == 3) {
  651.         value = cf->args->elts;
  652.         ltcf = ngx_http_conf_upstream_srv_conf(uscf,
  653.                                           ngx_http_upstream_least_time_module);
  654.         if (ngx_strcmp(value[2].data, "inflight") == 0) {
  655.             ltcf->use_inflight = 1;

  657.         } else {
  658.             ngx_conf_log_error(NGX_LOG_EMERG, cf, 0,
  659.                                "invalid parameter \"%V\"", &value[2]);
  660.             return NGX_CONF_ERROR;
  661.         }
  662.     }

  664.     return ngx_conf_set_enum_slot(cf, cmd, conf);
  665. }

One Level Up Top Level