RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-03-06 03:18:43 +00:00
Code Issues Packages Projects Releases Wiki Activity
f4e38b36b8
haproxy/src/lb_map.c

273 lines
7.0 KiB
C
Raw Normal View History

[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
/*
* Map-based load-balancing (RR and HASH)
*
* Copyright 2000-2009 Willy Tarreau <w@1wt.eu>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
*/
#include <common/compat.h>
#include <common/config.h>
#include <common/debug.h>
[MEDIUM] build: switch ebtree users to use new ebtree version All files referencing the previous ebtree code were changed to point to the new one in the ebtree directory. A makefile variable (EBTREE_DIR) is also available to use files from another directory. The ability to build the libebtree library temporarily remains disabled because it can have an impact on some existing toolchains and does not appear worth it in the medium term if we add support for multi-criteria stickiness for instance.
2009-10-26 20:10:04 +00:00
#include <eb32tree.h>
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
#include <types/global.h>
#include <types/server.h>
#include <proto/backend.h>
#include <proto/proto_http.h>
#include <proto/proto_tcp.h>
#include <proto/queue.h>
/* this function updates the map according to server <srv>'s new state */
static void map_set_server_status_down(struct server *srv)
{
struct proxy *p = srv->proxy;
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 17:27:31 +00:00
if (!srv_lb_status_changed(srv))
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
return;
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 16:51:40 +00:00
if (srv_is_usable(srv))
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
goto out_update_state;
/* FIXME: could be optimized since we know what changed */
recount_servers(p);
update_backend_weight(p);
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
p->lbprm.map.state |= LB_MAP_RECALC;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
out_update_state:
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 17:27:31 +00:00
srv_lb_commit_status(srv);
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
}
/* This function updates the map according to server <srv>'s new state */
static void map_set_server_status_up(struct server *srv)
{
struct proxy *p = srv->proxy;
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 17:27:31 +00:00
if (!srv_lb_status_changed(srv))
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
return;
MINOR: server: create srv_was_usable() from srv_is_usable() and use a pointer We used to call srv_is_usable() with either the current state and weights or the previous ones. This causes trouble for future changes, so let's first split it in two variants : - srv_is_usable(srv) considers the current status - srv_was_usable(srv) considers the previous status
2014-05-13 16:51:40 +00:00
if (!srv_is_usable(srv))
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
goto out_update_state;
/* FIXME: could be optimized since we know what changed */
recount_servers(p);
update_backend_weight(p);
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
p->lbprm.map.state |= LB_MAP_RECALC;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
out_update_state:
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 17:27:31 +00:00
srv_lb_commit_status(srv);
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
}
/* This function recomputes the server map for proxy px. It relies on
* px->lbprm.tot_wact, tot_wbck, tot_used, tot_weight, so it must be
* called after recount_servers(). It also expects px->lbprm.map.srv
* to be allocated with the largest size needed. It updates tot_weight.
*/
void recalc_server_map(struct proxy *px)
{
int o, tot, flag;
struct server *cur, *best;
switch (px->lbprm.tot_used) {
case 0: /* no server */
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
px->lbprm.map.state &= ~LB_MAP_RECALC;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
return;
default:
tot = px->lbprm.tot_weight;
break;
}
/* here we *know* that we have some servers */
if (px->srv_act)
REORG/MEDIUM: server: split server state and flags in two different variables Till now, the server's state and flags were all saved as a single bit field. It causes some difficulties because we'd like to have an enum for the state and separate flags. This commit starts by splitting them in two distinct fields. The first one is srv->state (with its counter-part srv->prev_state) which are now enums, but which still contain bits (SRV_STF_*). The flags now lie in their own field (srv->flags). The function srv_is_usable() was updated to use the enum as input, since it already used to deal only with the state. Note that currently, the maintenance mode is still in the state for simplicity, but it must move as well.
2014-05-13 13:54:22 +00:00
flag = 0;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
else
REORG/MEDIUM: server: split server state and flags in two different variables Till now, the server's state and flags were all saved as a single bit field. It causes some difficulties because we'd like to have an enum for the state and separate flags. This commit starts by splitting them in two distinct fields. The first one is srv->state (with its counter-part srv->prev_state) which are now enums, but which still contain bits (SRV_STF_*). The flags now lie in their own field (srv->flags). The function srv_is_usable() was updated to use the enum as input, since it already used to deal only with the state. Note that currently, the maintenance mode is still in the state for simplicity, but it must move as well.
2014-05-13 13:54:22 +00:00
flag = SRV_F_BACKUP;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
/* this algorithm gives priority to the first server, which means that
* it will respect the declaration order for equivalent weights, and
* that whatever the weights, the first server called will always be
* the first declared. This is an important asumption for the backup
* case, where we want the first server only.
*/
for (cur = px->srv; cur; cur = cur->next)
cur->wscore = 0;
for (o = 0; o < tot; o++) {
int max = 0;
best = NULL;
for (cur = px->srv; cur; cur = cur->next) {
if (cur->eweight &&
REORG/MEDIUM: server: split server state and flags in two different variables Till now, the server's state and flags were all saved as a single bit field. It causes some difficulties because we'd like to have an enum for the state and separate flags. This commit starts by splitting them in two distinct fields. The first one is srv->state (with its counter-part srv->prev_state) which are now enums, but which still contain bits (SRV_STF_*). The flags now lie in their own field (srv->flags). The function srv_is_usable() was updated to use the enum as input, since it already used to deal only with the state. Note that currently, the maintenance mode is still in the state for simplicity, but it must move as well.
2014-05-13 13:54:22 +00:00
(cur->flags & SRV_F_BACKUP) == flag &&
MAJOR: server: use states instead of flags to store the server state Servers used to have 3 flags to store a state, now they have 4 states instead. This avoids lots of confusion for the 4 remaining undefined states. The encoding from the previous to the new states can be represented this way : SRV_STF_RUNNING | SRV_STF_GOINGDOWN | | SRV_STF_WARMINGUP | | | 0 x x SRV_ST_STOPPED 1 0 0 SRV_ST_RUNNING 1 0 1 SRV_ST_STARTING 1 1 x SRV_ST_STOPPING Note that the case where all bits were set used to exist and was randomly dealt with. For example, the task was not stopped, the throttle value was still updated and reported in the stats and in the http_server_state header. It was the same if the server was stopped by the agent or for maintenance. It's worth noting that the internal function names are still quite confusing.
2014-05-13 21:41:20 +00:00
(cur->state == SRV_ST_STARTING || cur->state == SRV_ST_RUNNING)) {
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
int v;
/* If we are forced to return only one server, we don't want to
* go further, because we would return the wrong one due to
* divide overflow.
*/
if (tot == 1) {
best = cur;
/* note that best->wscore will be wrong but we don't care */
break;
}
cur->wscore += cur->eweight;
v = (cur->wscore + tot) / tot; /* result between 0 and 3 */
if (best == NULL || v > max) {
max = v;
best = cur;
}
}
}
px->lbprm.map.srv[o] = best;
best->wscore -= tot;
}
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
px->lbprm.map.state &= ~LB_MAP_RECALC;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
}
/* This function is responsible of building the server MAP for map-based LB
* algorithms, allocating the map, and setting p->lbprm.wmult to the GCD of the
* weights if applicable. It should be called only once per proxy, at config
* time.
*/
void init_server_map(struct proxy *p)
{
struct server *srv;
int pgcd;
int act, bck;
p->lbprm.set_server_status_up = map_set_server_status_up;
p->lbprm.set_server_status_down = map_set_server_status_down;
p->lbprm.update_server_eweight = NULL;
if (!p->srv)
return;
/* We will factor the weights to reduce the table,
* using Euclide's largest common divisor algorithm.
* Since we may have zero weights, we have to first
* find a non-zero weight server.
*/
pgcd = 1;
srv = p->srv;
while (srv && !srv->uweight)
srv = srv->next;
if (srv) {
pgcd = srv->uweight; /* note: cannot be zero */
while (pgcd > 1 && (srv = srv->next)) {
int w = srv->uweight;
while (w) {
int t = pgcd % w;
pgcd = w;
w = t;
}
}
}
/* It is sometimes useful to know what factor to apply
* to the backend's effective weight to know its real
* weight.
*/
p->lbprm.wmult = pgcd;
act = bck = 0;
for (srv = p->srv; srv; srv = srv->next) {
BUG/MAJOR: server: weight calculation fails for map-based algorithms A crash was reported by Igor at owind when changing a server's weight on the CLI. Lukas Tribus could reproduce a related bug where setting a server's weight would result in the new weight being multiplied by the initial one. The two bugs are the same. The incorrect weight calculation results in the total farm weight being larger than what was initially allocated, causing the map index to be out of bounds on some hashes. It's easy to reproduce using "balance url_param" with a variable param, or with "balance static-rr". It appears that the calculation is made at many places and is not always right and not always wrong the same way. Thus, this patch introduces a new function "server_recalc_eweight()" which is dedicated to this task of computing ->eweight from many other elements including uweight and current time (for slowstart), and all users now switch to use this function. The patch is a bit large but the code was not trivially fixable in a way that could guarantee this situation would not occur anymore. The fix is much more readable and has been verified to work with all algorithms, with both consistent and map-based hashes, and even with static-rr. Slowstart was tested as well, just like enable/disable server. The same bug is very likely present in 1.4 as well, so the patch will probably need to be backported eventhough it will not apply as-is. Thanks to Lukas and Igor for the information they provided to reproduce it.
2013-11-21 10:22:01 +00:00
srv->eweight = (srv->uweight * p->lbprm.wdiv + p->lbprm.wmult - 1) / p->lbprm.wmult;
MINOR: server: use functions to detect state changes and to update them Detecting that a server's status has changed is a bit messy, as well as it is to commit the status changes. We'll have to add new conditions soon and we'd better avoid to multiply the number of touched locations with the high risk of forgetting them. This commit introduces : - srv_lb_status_changed() to report if the status changed from the previously committed one ; - svr_lb_commit_status() to commit the current status The function is now used by all load-balancing algorithms.
2014-05-13 17:27:31 +00:00
srv_lb_commit_status(srv);
REORG/MEDIUM: server: split server state and flags in two different variables Till now, the server's state and flags were all saved as a single bit field. It causes some difficulties because we'd like to have an enum for the state and separate flags. This commit starts by splitting them in two distinct fields. The first one is srv->state (with its counter-part srv->prev_state) which are now enums, but which still contain bits (SRV_STF_*). The flags now lie in their own field (srv->flags). The function srv_is_usable() was updated to use the enum as input, since it already used to deal only with the state. Note that currently, the maintenance mode is still in the state for simplicity, but it must move as well.
2014-05-13 13:54:22 +00:00
if (srv->flags & SRV_F_BACKUP)
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
bck += srv->eweight;
else
act += srv->eweight;
}
/* this is the largest map we will ever need for this servers list */
if (act < bck)
act = bck;
if (!act)
act = 1;
p->lbprm.map.srv = (struct server **)calloc(act, sizeof(struct server *));
/* recounts servers and their weights */
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
p->lbprm.map.state = LB_MAP_RECALC;
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
recount_servers(p);
update_backend_weight(p);
recalc_server_map(p);
}
/*
* This function tries to find a running server with free connection slots for
* the proxy <px> following the round-robin method.
* If any server is found, it will be returned and px->lbprm.map.rr_idx will be updated
* to point to the next server. If no valid server is found, NULL is returned.
*/
struct server *map_get_server_rr(struct proxy *px, struct server *srvtoavoid)
{
int newidx, avoididx;
struct server *srv, *avoided;
if (px->lbprm.tot_weight == 0)
return NULL;
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
if (px->lbprm.map.state & LB_MAP_RECALC)
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
recalc_server_map(px);
if (px->lbprm.map.rr_idx < 0 || px->lbprm.map.rr_idx >= px->lbprm.tot_weight)
px->lbprm.map.rr_idx = 0;
newidx = px->lbprm.map.rr_idx;
avoided = NULL;
avoididx = 0; /* shut a gcc warning */
do {
srv = px->lbprm.map.srv[newidx++];
BUG/MINOR: use the same check condition for server as other algorithms Such load balance algorithms as roundrobin, leastconn and first will check the server after being selected with the following condition: if (!s->maxconn || (!s->nbpend && s->served < srv_dynamic_maxconn(s))) But static-rr uses the different one in map_get_server_rr() as below: if (!srv->maxconn || srv->cur_sess < srv_dynamic_maxconn(srv)) After viewing this difference, it is a better choice for static-rr to use the same check condition as other algorithms. This change will only affect static-rr. Though all hash algorithms with type map-based will use the same server map as static-rr, they call another function map_get_server_hash() to get server. Signed-off-by: Godbach <nylzhaowei@gmail.com>
2013-08-07 01:48:23 +00:00
if (!srv->maxconn || (!srv->nbpend && srv->served < srv_dynamic_maxconn(srv))) {
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
/* make sure it is not the server we are try to exclude... */
if (srv != srvtoavoid) {
px->lbprm.map.rr_idx = newidx;
return srv;
}
avoided = srv; /* ...but remember that is was selected yet avoided */
avoididx = newidx;
}
if (newidx == px->lbprm.tot_weight)
newidx = 0;
} while (newidx != px->lbprm.map.rr_idx);
if (avoided)
px->lbprm.map.rr_idx = avoididx;
/* return NULL or srvtoavoid if found */
return avoided;
}
[MINOR] lb_map: reorder code in order to ease integration of new hash functions We need to remove hash map accesses out of backend.c if we want to later support new hash methods. This patch separates the hash computation method from the server lookup. It leaves the lookup function to lb_map.c and calls it with the result of the hash.
2009-10-01 19:11:15 +00:00
/*
* This function returns the running server from the map at the location
* pointed to by the result of a modulo operation on <hash>. The server map may
* be recomputed if required before being looked up. If any server is found, it
* will be returned. If no valid server is found, NULL is returned.
*/
struct server *map_get_server_hash(struct proxy *px, unsigned int hash)
{
if (px->lbprm.tot_weight == 0)
return NULL;
[CLEANUP] proxy: move last lb-specific bits to their respective files The lbprm structure has moved to backend.h, where it should be, and all algo-specific types and declarations have moved to their specific files. The proxy struct is now much more readable.
2009-10-03 09:21:53 +00:00
if (px->lbprm.map.state & LB_MAP_RECALC)
[MINOR] lb_map: reorder code in order to ease integration of new hash functions We need to remove hash map accesses out of backend.c if we want to later support new hash methods. This patch separates the hash computation method from the server lookup. It leaves the lookup function to lb_map.c and calls it with the result of the hash.
2009-10-01 19:11:15 +00:00
recalc_server_map(px);
return px->lbprm.map.srv[hash % px->lbprm.tot_weight];
}
[CLEANUP] backend: move LB algos to individual files It was becoming painful to have all the LB algos in backend.c. Let's move them to their own files. A few hashing functions still need be broken in two parts, one for the contents and one for the map position.
2009-10-01 09:19:37 +00:00
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink