diff --git a/src/auth/pool_auth.c b/src/auth/pool_auth.c index 9425a0f2..0286f8f9 100644 --- a/src/auth/pool_auth.c +++ b/src/auth/pool_auth.c @@ -21,6 +21,7 @@ */ #include "pool.h" +#include #include "context/pool_session_context.h" #include "protocol/pool_process_query.h" #include "protocol/pool_proto_modules.h" @@ -34,11 +35,11 @@ #include "utils/palloc.h" #include "utils/memutils.h" #include "auth/md5.h" +#include #ifdef HAVE_CRYPT_H #include #endif - #ifdef HAVE_SYS_TYPES_H #include #endif diff --git a/src/config/pool_config_variables.c b/src/config/pool_config_variables.c index fe1bfd71..22d5d101 100644 --- a/src/config/pool_config_variables.c +++ b/src/config/pool_config_variables.c @@ -236,6 +236,21 @@ static const struct config_enum_entry backend_clustering_mode_options[] = { {NULL, 0, false} }; +static const struct config_enum_entry process_management_mode_options[] = { + {"static", PM_STATIC, false}, + {"dynamic", PM_DYNAMIC, false}, + + {NULL, 0, false} +}; + +static const struct config_enum_entry process_management_strategy_options[] = { + {"aggressive", PM_STRATEGY_AGGRESSIVE, false}, + {"gentle", PM_STRATEGY_GENTLE, false}, + {"lazy", PM_STRATEGY_LAZY, false}, + + {NULL, 0, false} +}; + static const struct config_enum_entry log_standby_delay_options[] = { {"always", LSD_ALWAYS, false}, {"if_over_threshold", LSD_OVER_THRESHOLD, false}, @@ -1886,7 +1901,7 @@ static struct config_int ConfigureNamesInt[] = { {"num_init_children", CFGCXT_INIT, CONNECTION_POOL_CONFIG, - "Number of children pre-forked for client connections.", + "Maximim number of child processs to handle client connections.", CONFIG_VAR_TYPE_INT, false, 0 }, &g_pool_config.num_init_children, @@ -1895,6 +1910,28 @@ static struct config_int ConfigureNamesInt[] = NULL, NULL, NULL }, + { + {"min_spare_children", CFGCXT_RELOAD, CONNECTION_POOL_CONFIG, + "Minimum number of spare child processes.", + CONFIG_VAR_TYPE_INT, false, 0 + }, + &g_pool_config.min_spare_children, + 5, + 1, INT_MAX, + NULL, NULL, NULL + }, + + { + {"max_spare_children", CFGCXT_RELOAD, CONNECTION_POOL_CONFIG, + "Maximum number of spare child processes.", + CONFIG_VAR_TYPE_INT, false, 0 + }, + &g_pool_config.max_spare_children, + 10, + 1, INT_MAX, + NULL, NULL, NULL + }, + { {"reserved_connections", CFGCXT_INIT, CONNECTION_POOL_CONFIG, "Number of reserved connections.", @@ -2236,6 +2273,27 @@ static struct config_enum ConfigureNamesEnum[] = NULL, NULL, NULL, NULL }, + { + {"process_management_mode", CFGCXT_RELOAD, CONNECTION_POOL_CONFIG, + "child process management mode.", + CONFIG_VAR_TYPE_ENUM, false, 0 + }, + (int *) &g_pool_config.process_management, + PM_STATIC, + process_management_mode_options, + NULL, NULL, NULL, NULL + }, + + { + {"process_management_strategy", CFGCXT_RELOAD, CONNECTION_POOL_CONFIG, + "child process management strategy.", + CONFIG_VAR_TYPE_ENUM, false, 0 + }, + (int *) &g_pool_config.process_management_strategy, + PM_STRATEGY_GENTLE, + process_management_strategy_options, + NULL, NULL, NULL, NULL + }, { {"syslog_facility", CFGCXT_RELOAD, LOGGING_CONFIG, @@ -4853,6 +4911,14 @@ config_post_processor(ConfigContext context, int elevel) (errmsg("invalid configuration, failover_when_quorum_exists is not allowed in native replication mode"))); return false; } + + if (pool_config->min_spare_children >= pool_config->max_spare_children) + { + ereport(elevel, + (errmsg("invalid configuration, max_spare_children:%d must be greater than max_spare_children:%d", + pool_config->max_spare_children,pool_config->min_spare_children))); + return false; + } return true; } diff --git a/src/context/pool_process_context.c b/src/context/pool_process_context.c index 51b08bed..00a04ff8 100644 --- a/src/context/pool_process_context.c +++ b/src/context/pool_process_context.c @@ -230,25 +230,30 @@ pool_coninfo_backend_pid(int backend_pid, int *backend_node_id) for (child = 0; child < pool_config->num_init_children; child++) { int pool; - ProcessInfo *pi = pool_get_process_info(process_info[child].pid); - for (pool = 0; pool < pool_config->max_pool; pool++) + if (process_info[child].pid) { - int backend_id; + ProcessInfo *pi = pool_get_process_info(process_info[child].pid); - for (backend_id = 0; backend_id < NUM_BACKENDS; backend_id++) + for (pool = 0; pool < pool_config->max_pool; pool++) { - int poolBE = pool * MAX_NUM_BACKENDS + backend_id; + int backend_id; - if (ntohl(pi->connection_info[poolBE].pid) == backend_pid) + for (backend_id = 0; backend_id < NUM_BACKENDS; backend_id++) { - ereport(DEBUG1, - (errmsg("found for the connection with backend pid:%d on backend node %d", backend_pid, backend_id))); - *backend_node_id = backend_id; - return &pi->connection_info[poolBE]; + int poolBE = pool * MAX_NUM_BACKENDS + backend_id; + + if (ntohl(pi->connection_info[poolBE].pid) == backend_pid) + { + ereport(DEBUG1, + (errmsg("found the connection with backend pid:%d on backend node %d", backend_pid, backend_id))); + *backend_node_id = backend_id; + return &pi->connection_info[poolBE]; + } } } } + } return NULL; } diff --git a/src/include/main/pool_internal_comms.h b/src/include/main/pool_internal_comms.h index 1709d1ad..6b4dc60d 100644 --- a/src/include/main/pool_internal_comms.h +++ b/src/include/main/pool_internal_comms.h @@ -42,5 +42,4 @@ extern void register_backend_state_sync_req_interrupt(void); extern void register_inform_quarantine_nodes_req(void); extern bool register_node_operation_request(POOL_REQUEST_KIND kind, int *node_id_set, int count, unsigned char flags); - #endif /* pool_internal_comms_h */ diff --git a/src/include/pcp/libpcp_ext.h b/src/include/pcp/libpcp_ext.h index 9d2c0cfd..2d86dd30 100644 --- a/src/include/pcp/libpcp_ext.h +++ b/src/include/pcp/libpcp_ext.h @@ -124,7 +124,8 @@ typedef enum WAIT_FOR_CONNECT, COMMAND_EXECUTE, IDLE, - IDLE_IN_TRANS + IDLE_IN_TRANS, + CONNECTING } ProcessStatus; /* @@ -176,10 +177,13 @@ typedef struct * this process */ int client_connection_count; /* how many times clients used this process */ ProcessStatus status; - char need_to_restart; /* If non 0, exit this child process as + bool need_to_restart; /* If non 0, exit this child process as * soon as current session ends. Typical * case this flag being set is failback a * node in streaming replication mode. */ + bool exit_if_idle; + int pooled_connections; /* Total number of pooled connections + * by this child */ } ProcessInfo; /* diff --git a/src/include/pool.h b/src/include/pool.h index c8d97abf..645211b9 100644 --- a/src/include/pool.h +++ b/src/include/pool.h @@ -593,6 +593,7 @@ extern BACKEND_STATUS private_backend_status[MAX_NUM_BACKENDS]; extern char remote_host[]; /* client host */ extern char remote_port[]; /* client port */ + /* * public functions */ diff --git a/src/include/pool_config.h b/src/include/pool_config.h index b6967cf2..4404c3cd 100644 --- a/src/include/pool_config.h +++ b/src/include/pool_config.h @@ -57,6 +57,19 @@ typedef struct regex_t regexv; } RegPattern; +typedef enum ProcessManagementModes +{ + PM_STATIC = 1, + PM_DYNAMIC +} ProcessManagementModes; + +typedef enum ProcessManagementSstrategies +{ + PM_STRATEGY_AGGRESSIVE = 1, + PM_STRATEGY_GENTLE, + PM_STRATEGY_LAZY +} ProcessManagementSstrategies; + typedef enum NativeReplicationSubModes { SLONY_MODE = 1, @@ -203,6 +216,8 @@ typedef struct typedef struct { ClusteringModes backend_clustering_mode; /* Backend clustering mode */ + ProcessManagementModes process_management; + ProcessManagementSstrategies process_management_strategy; char **listen_addresses; /* hostnames/IP addresses to listen on */ int port; /* port # to bind */ char **pcp_listen_addresses; /* PCP listen address to listen on */ @@ -212,7 +227,10 @@ typedef struct int unix_socket_permissions; /* pgpool sockets permissions */ char *wd_ipc_socket_dir; /* watchdog command IPC socket directory */ char *pcp_socket_dir; /* PCP socket directory */ - int num_init_children; /* # of children initially pre-forked */ + int num_init_children; /* Maximum number of child to + * accept connections */ + int min_spare_children; /* Minimum number of idle children */ + int max_spare_children; /* Minimum number of idle children */ int listen_backlog_multiplier; /* determines the size of the * connection queue */ int reserved_connections; /* # of reserved connections */ diff --git a/src/include/protocol/pool_connection_pool.h b/src/include/protocol/pool_connection_pool.h index 19b8f72a..aee976d7 100644 --- a/src/include/protocol/pool_connection_pool.h +++ b/src/include/protocol/pool_connection_pool.h @@ -37,4 +37,5 @@ extern int connect_inet_domain_socket_by_port(char *host, int port, bool retry); extern int connect_unix_domain_socket_by_port(int port, char *socket_dir, bool retry); extern int pool_pool_index(void); extern void close_all_backend_connections(void); +extern void update_pooled_connection_count(void); #endif /* pool_connection_pool_h */ diff --git a/src/main/pgpool_main.c b/src/main/pgpool_main.c index e4e5a9ea..6f149c09 100644 --- a/src/main/pgpool_main.c +++ b/src/main/pgpool_main.c @@ -115,6 +115,8 @@ typedef struct User1SignalSlot #endif #define PGPOOLMAXLITSENQUEUELENGTH 10000 +#define MAX_ONE_SHOT_KILLS 8 + #define UNIXSOCK_PATH_BUFLEN sizeof(((struct sockaddr_un *) NULL)->sun_path) @@ -196,12 +198,16 @@ static void exec_notice_pcp_child(FAILOVER_CONTEXT *failover_context); static void check_requests(void); static void print_signal_member(sigset_t *sig); +static void service_child_processes(void); +static int select_victim_processes(int *process_info_idxs, int count); static struct sockaddr_un *un_addrs; /* unix domain socket path */ static struct sockaddr_un pcp_un_addr; /* unix domain socket path for PCP */ ProcessInfo *process_info = NULL; /* Per child info table on shmem */ volatile User1SignalSlot *user1SignalSlot = NULL; /* User 1 signal slot on * shmem */ +int current_child_process_count; + struct timeval random_start_time; /* @@ -498,15 +504,24 @@ PgpoolMain(bool discard_status, bool clear_memcache_oidmaps) * is harmless. */ POOL_SETMASK(&BlockSig); + + if (pool_config->process_management == PM_DYNAMIC) + current_child_process_count = pool_config->max_spare_children; + else + current_child_process_count = pool_config->num_init_children; + /* fork the children */ - for (i = 0; i < pool_config->num_init_children; i++) + for (i = 0; i < current_child_process_count; i++) { - process_info[i].pid = fork_a_child(fds, i); process_info[i].start_time = time(NULL); process_info[i].client_connection_count = 0; process_info[i].status = WAIT_FOR_CONNECT; process_info[i].connected = 0; process_info[i].wait_for_connect = 0; + process_info[i].pooled_connections = 0; + process_info[i].need_to_restart = false; + process_info[i].exit_if_idle = false; + process_info[i].pid = fork_a_child(fds, i); } /* create pipe for delivering event */ @@ -639,11 +654,15 @@ PgpoolMain(bool discard_status, bool clear_memcache_oidmaps) for (;;) { int r; - struct timeval t = {3, 0}; + struct timeval t = {2, 0}; POOL_SETMASK(&UnBlockSig); r = pool_pause(&t); POOL_SETMASK(&BlockSig); + + if (pool_config->process_management == PM_DYNAMIC) + service_child_processes(); + if (r > 0) break; } @@ -1941,7 +1960,8 @@ reaper(void) { found = true; /* if found, fork a new child */ - if (!switching && !exiting && restart_child) + if (!switching && !exiting && restart_child && + pool_config->process_management == PM_DYNAMIC) { process_info[i].pid = fork_a_child(fds, i); process_info[i].start_time = time(NULL); @@ -1952,7 +1972,10 @@ reaper(void) process_info[i].wait_for_connect = 0; } else + { + current_child_process_count--; process_info[i].pid = 0; + } break; } } @@ -2033,12 +2056,19 @@ int * pool_get_process_list(int *array_size) { int *array; + int cnt = 0; int i; - *array_size = pool_config->num_init_children; + *array_size = current_child_process_count; array = palloc0(*array_size * sizeof(int)); - for (i = 0; i < *array_size; i++) - array[i] = process_info[i].pid; + for (i = 0; i < pool_config->num_init_children || cnt < *array_size; i++) + { + if (process_info[i].pid != 0) + { + array[cnt] = process_info[i].pid; + cnt++; + } + } return array; } @@ -2960,7 +2990,10 @@ initialize_shared_mem_objects(bool clear_memcache_oidmaps) process_info = (ProcessInfo *)pool_shared_memory_segment_get_chunk(pool_config->num_init_children * (sizeof(ProcessInfo))); for (i = 0; i < pool_config->num_init_children; i++) + { process_info[i].connection_info = pool_coninfo(i, 0, 0); + process_info[i].pid = 0; + } user1SignalSlot = (User1SignalSlot *)pool_shared_memory_segment_get_chunk(sizeof(User1SignalSlot)); @@ -3717,6 +3750,7 @@ sync_backend_from_watchdog(void) process_info[i].status = WAIT_FOR_CONNECT; process_info[i].connected = 0; process_info[i].wait_for_connect = 0; + process_info[i].pooled_connections = 0; } } else @@ -3732,7 +3766,8 @@ sync_backend_from_watchdog(void) */ for (i = 0; i < pool_config->num_init_children; i++) { - process_info[i].need_to_restart = 1; + if (process_info[i].pid) + process_info[i].need_to_restart = 1; } } @@ -4581,6 +4616,8 @@ exec_child_restart(FAILOVER_CONTEXT *failover_context, int node_id) process_info[i].status = WAIT_FOR_CONNECT; process_info[i].connected = 0; process_info[i].wait_for_connect = 0; + process_info[i].pooled_connections = 0; + } } else @@ -4873,3 +4910,180 @@ void print_signal_member(sigset_t *sig) ereport(LOG, (errmsg("SIGTERM is member"))); } + +/* +* Function does the house keeping of spare child processes +*/ +static void +service_child_processes(void) +{ + int connected_children = Req_info->conn_counter; + int idle_children = current_child_process_count - connected_children; + static int high_load_counter = 0; + ereport(DEBUG2, + (errmsg("current_children_count = %d idle_children = %d connected_children = %d high_load_counter = %d", + current_child_process_count, idle_children, connected_children, high_load_counter))); + if (idle_children > pool_config->max_spare_children) + { + int ki; + int victim_count; + int kill_process_info_idxs[MAX_ONE_SHOT_KILLS]; + int kill_count = idle_children - pool_config->max_spare_children; + int cycle_skip_count_before_scale_down; + int cycle_skip_between_scale_down; + int one_shot_kill_count; + + switch (pool_config->process_management_strategy) + { + case PM_STRATEGY_AGGRESSIVE: + cycle_skip_count_before_scale_down = 25; /* roughly 50 seconds */ + cycle_skip_between_scale_down = 2; + one_shot_kill_count = MAX_ONE_SHOT_KILLS; + break; + + case PM_STRATEGY_LAZY: + cycle_skip_count_before_scale_down = 150; /* roughly 300 seconds */ + cycle_skip_between_scale_down = 10; + one_shot_kill_count = 3; + break; + + case PM_STRATEGY_GENTLE: + cycle_skip_count_before_scale_down = 60; /* roughly 120 seconds */ + cycle_skip_between_scale_down = 5; + one_shot_kill_count = 3; + break; + + default: + /* should never come here, but if we do use gentle counts*/ + cycle_skip_count_before_scale_down = 60; /* roughly 120 seconds */ + cycle_skip_between_scale_down = 5; + one_shot_kill_count = 3; + break; + } + + /* Do not scale down too quickly */ + if (++high_load_counter < cycle_skip_count_before_scale_down || high_load_counter % cycle_skip_between_scale_down) + return; + + memset(kill_process_info_idxs, -1 ,sizeof(kill_process_info_idxs)); + + if (kill_count > one_shot_kill_count) + kill_count = one_shot_kill_count; + + victim_count = select_victim_processes(kill_process_info_idxs, kill_count); + + for (ki = 0; ki < victim_count; ki++) + { + int index = kill_process_info_idxs[ki]; + if (index >=0) + { + if (process_info[index].pid && process_info[index].status == WAIT_FOR_CONNECT) + { + ereport(DEBUG1, + (errmsg("asking child process with pid:%d to kill itself to satisfy max_spare_children", + process_info[index].pid), + errdetail("child process has %d pooled connections",process_info[index].pooled_connections))); + process_info[index].exit_if_idle = true; + kill(process_info[index].pid, SIGUSR2); + } + } + } + } + else + { + /* Reset the high load counter */ + high_load_counter = 0; + /*See if we need to spawn new children */ + if (idle_children < pool_config->min_spare_children) + { + int i; + int spawned = 0; + int new_spawn_no = pool_config->min_spare_children - idle_children; + /* Add 25% of max_spare_children */ + new_spawn_no += pool_config->max_spare_children / 4; + if (new_spawn_no + current_child_process_count > pool_config->num_init_children) + { + ereport(LOG, + (errmsg("we have hit the ceiling, spawning %d child(ren)", + pool_config->num_init_children - current_child_process_count))); + new_spawn_no = pool_config->num_init_children - current_child_process_count; + } + if (new_spawn_no <= 0) + return; + for (i = 0; i < pool_config->num_init_children; i++) + { + if (process_info[i].pid == 0) + { + process_info[i].start_time = time(NULL); + process_info[i].client_connection_count = 0; + process_info[i].status = WAIT_FOR_CONNECT; + process_info[i].connected = 0; + process_info[i].wait_for_connect = 0; + process_info[i].pooled_connections = 0; + process_info[i].need_to_restart = 0; + process_info[i].exit_if_idle = false; + process_info[i].pid = fork_a_child(fds, i); + + current_child_process_count++; + if (++spawned >= new_spawn_no) + break; + } + } + } + } +} + +/* + * Function selects the child processes that can be killed based. + * selection criteria is to select the processes with minimum number of + * pooled connections. + * Returns the total number of identified process and fills the proc_info_arr + * with the victim children process_info index + */ +static int +select_victim_processes(int *process_info_idxs, int count) +{ + int i, ki; + bool found_enough = false; + int selected_count = 0; + + if (count <= 0) + return 0; + + for (i = 0; i < pool_config->num_init_children; i++) + { + /* Only the child process in waiting for connect can be terminated */ + if (process_info[i].pid && process_info[i].status == WAIT_FOR_CONNECT) + { + if (selected_count < count) + { + process_info_idxs[selected_count++] = i; + } + else + { + found_enough = true; + /* we don't bother selecting the child having least pooled connection with + * aggressive strategy + */ + if (pool_config->process_management_strategy != PM_STRATEGY_AGGRESSIVE) + { + for (ki = 0; ki < count; ki++) + { + int old_index = process_info_idxs[ki]; + if (old_index < 0 || process_info[old_index].pooled_connections > process_info[i].pooled_connections) + { + process_info_idxs[ki] = i; + found_enough = false; + break; + } + if (process_info[old_index].pooled_connections) + found_enough = false; + } + } + } + } + if (found_enough) + break; + } + return selected_count; +} \ No newline at end of file diff --git a/src/protocol/child.c b/src/protocol/child.c index 9056a29a..f68c9eda 100644 --- a/src/protocol/child.c +++ b/src/protocol/child.c @@ -82,6 +82,7 @@ static bool connect_using_existing_connection(POOL_CONNECTION * frontend, POOL_CONNECTION_POOL * backend, StartupPacket *sp); static void check_restart_request(void); +static void check_exit_request(void); static void enable_authentication_timeout(void); static void disable_authentication_timeout(void); static int wait_for_new_connections(int *fds, SockAddr *saddr); @@ -300,7 +301,7 @@ do_child(int *fds) pool_close(child_frontend); child_frontend = NULL; } - + update_pooled_connection_count(); MemoryContextSwitchTo(TopMemoryContext); FlushErrorState(); } @@ -325,6 +326,7 @@ do_child(int *fds) /* pgpool stop request already sent? */ check_stop_request(); check_restart_request(); + check_exit_request(); accepted = 0; /* Destroy session context for just in case... */ pool_session_context_destroy(); @@ -345,6 +347,10 @@ do_child(int *fds) if (front_end_fd == RETRY) continue; + set_process_status(CONNECTING); + /* Reset any exit if idle request even if it's pending */ + pool_get_my_process_info()->exit_if_idle = false; + con_count = connection_count_up(); if (pool_config->reserved_connections > 0) @@ -459,7 +465,7 @@ do_child(int *fds) /* Mark this connection pool is not connected from frontend */ pool_coninfo_unset_frontend_connected(pool_get_process_context()->proc_id, pool_pool_index()); - + update_pooled_connection_count(); accepted = 0; connection_count_down(); if (pool_config->log_disconnections) @@ -483,6 +489,8 @@ do_child(int *fds) child_exit(POOL_EXIT_NO_RESTART); } + + /* ------------------------------------------------------------------- * private functions * ------------------------------------------------------------------- @@ -1432,6 +1440,23 @@ pool_initialize_private_backend_status(void) my_main_node_id = REAL_MAIN_NODE_ID; } +static void +check_exit_request(void) +{ + /* + * Check if exit request is set because of spare children management. + */ + if (pool_get_my_process_info()->exit_if_idle) + { + ereport(LOG, + (errmsg("Exit flag set"), + errdetail("Exiting myself"))); + + pool_get_my_process_info()->exit_if_idle = 0; + child_exit(POOL_EXIT_NO_RESTART); + } +} + static void check_restart_request(void) { @@ -1445,7 +1470,7 @@ check_restart_request(void) (errmsg("failover or failback event detected"), errdetail("restarting myself"))); - pool_get_my_process_info()->need_to_restart = 0; + pool_get_my_process_info()->need_to_restart = false; child_exit(POOL_EXIT_AND_RESTART); } } diff --git a/src/protocol/pool_connection_pool.c b/src/protocol/pool_connection_pool.c index ed28d870..7f3c44ce 100644 --- a/src/protocol/pool_connection_pool.c +++ b/src/protocol/pool_connection_pool.c @@ -471,7 +471,7 @@ pool_backend_timer(void) nearest = 1; pool_alarm(pool_backend_timer_handler, nearest); } - + update_pooled_connection_count(); POOL_SETMASK(&UnBlockSig); } @@ -1066,3 +1066,16 @@ close_all_backend_connections(void) POOL_SETMASK(&oldmask); } + +void update_pooled_connection_count(void) +{ + int i; + int count = 0; + POOL_CONNECTION_POOL *p = pool_connection_pool; + for (i = 0; i < pool_config->max_pool; i++) + { + if (MAIN_CONNECTION(p)) + count++; + } + pool_get_my_process_info()->pooled_connections = count; +} diff --git a/src/sample/pgpool.conf.sample-stream b/src/sample/pgpool.conf.sample-stream index 87678c7e..996eeb01 100644 --- a/src/sample/pgpool.conf.sample-stream +++ b/src/sample/pgpool.conf.sample-stream @@ -163,9 +163,45 @@ backend_clustering_mode = 'streaming_replication' # - Concurrent session and pool size - +#process_management_mode = static + # process management mode for child processes + # Valid options: + # static: all children are pre-forked at startup + # dynamic: child processes are spawned on demand. + # number of idle child processes at any time are + # configured by min_spare_children and max_spare_children + +#process_management_strategy = gentle + # process management strategy to satisfy spare processes + # Valid options: + # + # lazy: In this mode the scale down is performed gradually + # and only gets triggered when excessive spare processes count + # remains high for more than 5 mins + # + # gentle: In this mode the scale down is performed gradually + # and only gets triggered when excessive spare processes count + # remains high for more than 2 mins + # + # aggressive: In this mode the scale down is performed aggressively + # and gets triggered more frequently in case of higher spare processes. + # This mode uses faster and slightly less smart process selection criteria + # to identify the child processes that can be serviced to satisfy + # max_spare_children + # + # (Only applicable for dynamic process management mode) + #num_init_children = 32 - # Number of concurrent sessions allowed + # Maximum Number of concurrent sessions allowed # (change requires restart) +#min_spare_children = 5 + # Minimum number of spare child processes waiting for connection + # (Only applicable for dynamic process management mode) + +#max_spare_children = 10 + # Maximum number of idle child processes waiting for connection + # (Only applicable for dynamic process management mode) + #max_pool = 4 # Number of connection pool caches per connection # (change requires restart) diff --git a/src/tools/pcp/pcp_frontend_client.c b/src/tools/pcp/pcp_frontend_client.c index 4ae47ffa..ef068e29 100644 --- a/src/tools/pcp/pcp_frontend_client.c +++ b/src/tools/pcp/pcp_frontend_client.c @@ -4,7 +4,7 @@ * pgpool: a language independent connection pool server for PostgreSQL * written by Tatsuo Ishii * - * Copyright (c) 2003-2021 PgPool Global Development Group + * Copyright (c) 2003-2022 PgPool Global Development Group * * Permission to use, copy, modify, and distribute this software and * its documentation for any purpose and without fee is hereby @@ -745,7 +745,7 @@ output_procinfo_result(PCPResultInfo * pcpResInfo, bool all, bool verbose) if (pools == NULL) break; - if ((!all) && (pools->database[0] == '\0')) + if (((!all) && (pools->database[0] == '\0')) || (pools->pool_pid[0] == '\0')) continue; printed = true; printf(format, diff --git a/src/utils/pool_process_reporting.c b/src/utils/pool_process_reporting.c index 1dad43a9..96cbbfa0 100644 --- a/src/utils/pool_process_reporting.c +++ b/src/utils/pool_process_reporting.c @@ -335,10 +335,6 @@ get_config(int *nrows) /* POOLS */ /* - Pool size - */ - StrNCpy(status[i].name, "num_init_children", POOLCONFIG_MAXNAMELEN); - snprintf(status[i].value, POOLCONFIG_MAXVALLEN, "%d", pool_config->num_init_children); - StrNCpy(status[i].desc, "# of children initially pre-forked", POOLCONFIG_MAXDESCLEN); - i++; StrNCpy(status[i].name, "listen_backlog_multiplier", POOLCONFIG_MAXNAMELEN); snprintf(status[i].value, POOLCONFIG_MAXVALLEN, "%d", pool_config->listen_backlog_multiplier); @@ -360,6 +356,21 @@ get_config(int *nrows) StrNCpy(status[i].desc, "max # of connection pool per child", POOLCONFIG_MAXDESCLEN); i++; + StrNCpy(status[i].name, "num_init_children", POOLCONFIG_MAXNAMELEN); + snprintf(status[i].value, POOLCONFIG_MAXVALLEN, "%d", pool_config->num_init_children); + StrNCpy(status[i].desc, "# of children initially pre-forked", POOLCONFIG_MAXDESCLEN); + i++; + + StrNCpy(status[i].name, "min_spare_children", POOLCONFIG_MAXNAMELEN); + snprintf(status[i].value, POOLCONFIG_MAXVALLEN, "%d", pool_config->min_spare_children); + StrNCpy(status[i].desc, "min # of spare children waitting for connection", POOLCONFIG_MAXDESCLEN); + i++; + + StrNCpy(status[i].name, "max_spare_children", POOLCONFIG_MAXNAMELEN); + snprintf(status[i].value, POOLCONFIG_MAXVALLEN, "%d", pool_config->max_spare_children); + StrNCpy(status[i].desc, "max # of spare children waitting for connection", POOLCONFIG_MAXDESCLEN); + i++; + /* - Life time - */ StrNCpy(status[i].name, "child_life_time", POOLCONFIG_MAXNAMELEN); snprintf(status[i].value, POOLCONFIG_MAXVALLEN, "%d", pool_config->child_life_time); @@ -1615,6 +1626,9 @@ get_pools(int *nrows) case IDLE_IN_TRANS: StrNCpy(pools[lines].status, "Idle in transaction", POOLCONFIG_MAXPROCESSSTATUSLEN); break; + case CONNECTING: + StrNCpy(pools[lines].status, "Connecting", POOLCONFIG_MAXPROCESSSTATUSLEN); + break; default: *(pools[lines].status) = '\0'; } @@ -1733,6 +1747,9 @@ get_processes(int *nrows) case IDLE_IN_TRANS: StrNCpy(processes[child].status, "Idle in transaction", POOLCONFIG_MAXPROCESSSTATUSLEN); break; + case CONNECTING: + StrNCpy(processes[child].status, "Connecting", POOLCONFIG_MAXPROCESSSTATUSLEN); + break; default: *(processes[child].status) = '\0'; } diff --git a/src/watchdog/wd_json_data.c b/src/watchdog/wd_json_data.c index e1dd04f4..83842a75 100644 --- a/src/watchdog/wd_json_data.c +++ b/src/watchdog/wd_json_data.c @@ -48,8 +48,6 @@ get_pool_config_from_json(char *json_data, int data_len) if (root == NULL || root->type != json_object) goto ERROR_EXIT; - if (json_get_int_value_for_key(root, "num_init_children", &config->num_init_children)) - goto ERROR_EXIT; if (json_get_int_value_for_key(root, "listen_backlog_multiplier", &config->listen_backlog_multiplier)) goto ERROR_EXIT; if (json_get_int_value_for_key(root, "child_life_time", &config->child_life_time)) @@ -62,6 +60,16 @@ get_pool_config_from_json(char *json_data, int data_len) goto ERROR_EXIT; if (json_get_int_value_for_key(root, "max_pool", &config->max_pool)) goto ERROR_EXIT; + if (json_get_int_value_for_key(root, "num_init_children", &config->num_init_children)) + goto ERROR_EXIT; + if (json_get_int_value_for_key(root, "min_spare_children", &config->min_spare_children)) + goto ERROR_EXIT; + if (json_get_int_value_for_key(root, "max_spare_children", &config->max_spare_children)) + goto ERROR_EXIT; + if (json_get_int_value_for_key(root, "process_management_mode", (int*)&config->process_management)) + goto ERROR_EXIT; + if (json_get_int_value_for_key(root, "process_management_strategy", (int*)&config->process_management_strategy)) + goto ERROR_EXIT; if (json_get_bool_value_for_key(root, "replication_mode", &config->replication_mode)) goto ERROR_EXIT; if (json_get_bool_value_for_key(root, "enable_pool_hba", &config->enable_pool_hba)) @@ -174,13 +182,17 @@ get_pool_config_json(void) JsonNode *jNode = jw_create_with_object(true); - jw_put_int(jNode, "num_init_children", pool_config->num_init_children); jw_put_int(jNode, "listen_backlog_multiplier", pool_config->listen_backlog_multiplier); jw_put_int(jNode, "child_life_time", pool_config->child_life_time); jw_put_int(jNode, "connection_life_time", pool_config->connection_life_time); jw_put_int(jNode, "child_max_connections", pool_config->child_max_connections); jw_put_int(jNode, "client_idle_limit", pool_config->client_idle_limit); jw_put_int(jNode, "max_pool", pool_config->max_pool); + jw_put_int(jNode, "num_init_children", pool_config->num_init_children); + jw_put_int(jNode, "min_spare_children", pool_config->min_spare_children); + jw_put_int(jNode, "max_spare_children", pool_config->max_spare_children); + jw_put_int(jNode, "process_management_mode", pool_config->process_management); + jw_put_int(jNode, "process_management_strategy", pool_config->process_management_strategy); jw_put_bool(jNode, "replication_mode", pool_config->replication_mode); jw_put_bool(jNode, "enable_pool_hba", pool_config->enable_pool_hba); jw_put_bool(jNode, "load_balance_mode", pool_config->load_balance_mode);