mirror of
https://github.com/haproxy/haproxy.git
synced 2026-06-23 08:21:33 -04:00
5fe0579d49
Till now, threads were all started one at a time from thread 1. This will soon cause us limitations once we want to reduce shared stuff between thread groups. Let's slightly change the startup sequence so that the first thread starts one initial thread for each group, and that each of these threads then starts all other threads from their group before switching to the final task. Since it requires an intermediary step, we need to store that threads' start function to access it from the group, so it was put into the tgroup_info which still has plenty of room available. It could also theoretically speed up the boot sequence, though in practice it doesn't change anything because each thead's initialization is made one at a time to avoid races during the early boot. However ther is now a function in charge of starting all extra threads of a group, and whih is called from this group.
245 lines
13 KiB
C
245 lines
13 KiB
C
/*
|
|
* include/haproxy/tinfo-t.h
|
|
* Definitions of the thread_info structure.
|
|
*
|
|
* Copyright (C) 2020 Willy Tarreau - w@1wt.eu
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation, version 2.1
|
|
* exclusively.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
#ifndef _HAPROXY_TINFO_T_H
|
|
#define _HAPROXY_TINFO_T_H
|
|
|
|
#include <import/ebtree-t.h>
|
|
|
|
#include <haproxy/api-t.h>
|
|
#include <haproxy/freq_ctr-t.h>
|
|
#include <haproxy/thread-t.h>
|
|
|
|
/* forward declarations for types used below */
|
|
struct buffer;
|
|
|
|
/* Threads sets are known either by a set of absolute thread numbers, or by a
|
|
* set of relative thread numbers within a group, for each group. The default
|
|
* is the absolute mode and corresponds to the case where no group is known
|
|
* (nbgrp == 0). The mode may only be changed when the set is empty (use
|
|
* thread_set_is_empty() for this).
|
|
*/
|
|
struct thread_set {
|
|
union {
|
|
ulong abs[(MAX_THREADS + LONGBITS - 1) / LONGBITS];
|
|
ulong rel[MAX_TGROUPS];
|
|
};
|
|
ulong nbgrps; /* Number of thread groups, 0 for abs */
|
|
};
|
|
|
|
/* tasklet classes */
|
|
enum {
|
|
TL_URGENT = 0, /* urgent tasklets (I/O callbacks) */
|
|
TL_NORMAL = 1, /* normal tasks */
|
|
TL_BULK = 2, /* bulk task/tasklets, streaming I/Os */
|
|
TL_HEAVY = 3, /* heavy computational tasklets (e.g. TLS handshakes) */
|
|
TL_CLASSES /* must be last */
|
|
};
|
|
|
|
/* thread_ctx flags, for ha_thread_ctx[].flags. These flags describe the
|
|
* thread's state and are visible to other threads, so they must be used
|
|
* with atomic ops.
|
|
*/
|
|
#define TH_FL_STUCK 0x00000001
|
|
#define TH_FL_TASK_PROFILING 0x00000002
|
|
#define TH_FL_NOTIFIED 0x00000004 /* task was notified about the need to wake up */
|
|
#define TH_FL_SLEEPING 0x00000008 /* thread won't check its task list before next wakeup */
|
|
#define TH_FL_STARTED 0x00000010 /* set once the thread starts */
|
|
#define TH_FL_IN_LOOP 0x00000020 /* set only inside the polling loop */
|
|
/* unused 0x00000040 */
|
|
#define TH_FL_IN_SIG_HANDLER 0x00000080 /* thread currently in the generic signal handler */
|
|
#define TH_FL_IN_DBG_HANDLER 0x00000100 /* thread currently in the debug signal handler */
|
|
#define TH_FL_IN_WDT_HANDLER 0x00000200 /* thread currently in the wdt signal handler */
|
|
#define TH_FL_IN_ANY_HANDLER 0x00000380 /* mask to test if the thread is in any signal handler */
|
|
#define TH_FL_TASK_PROFILING_L 0x00000400 /* task profiling in locks (also requires TASK_PROFILING) */
|
|
#define TH_FL_TASK_PROFILING_M 0x00000800 /* task profiling in mem alloc (also requires TASK_PROFILING) */
|
|
|
|
/* we have 4 buffer-wait queues, in highest to lowest emergency order */
|
|
#define DYNBUF_NBQ 4
|
|
|
|
/* execution context, for tracing resource usage or warning origins */
|
|
enum thread_exec_ctx_type {
|
|
TH_EX_CTX_NONE = 0, /* context not filled */
|
|
TH_EX_CTX_OTHER, /* context only known by a generic pointer */
|
|
TH_EX_CTX_INITCALL, /* the pointer is an initcall providing file:line */
|
|
TH_EX_CTX_CALLER, /* the pointer is an ha_caller of the caller providing file:line etc */
|
|
TH_EX_CTX_SMPF, /* directly registered sample fetch function, using .smpf_kwl */
|
|
TH_EX_CTX_CONV, /* directly registered converter function, using .conv_kwl */
|
|
TH_EX_CTX_FUNC, /* hopefully recognizable function/callback, using .pointer */
|
|
TH_EX_CTX_ACTION, /* directly registered action function, using .action_kwl */
|
|
TH_EX_CTX_FLT, /* filter whose config is in .flt_conf */
|
|
TH_EX_CTX_MUX, /* mux whose mux_ops is in .mux_ops */
|
|
TH_EX_CTX_TASK, /* task or tasklet whose function is in .task */
|
|
TH_EX_CTX_APPLET, /* applet whose applet is in .applet */
|
|
TH_EX_CTX_CLI_KWL, /* CLI keyword list, using .cli_kwl */
|
|
};
|
|
|
|
struct thread_exec_ctx {
|
|
enum thread_exec_ctx_type type;
|
|
/* 32-bit hole here on 64-bit platforms */
|
|
union {
|
|
const void *pointer; /* generic pointer (for other) */
|
|
const struct initcall *initcall; /* used with TH_EX_CTX_INITCALL */
|
|
const struct ha_caller *ha_caller; /* used with TH_EX_CTX_CALLER */
|
|
const struct sample_fetch_kw_list *smpf_kwl; /* used with TH_EX_CTX_SMPF */
|
|
const struct sample_conv_kw_list *conv_kwl; /* used with TH_EX_CTX_CONV */
|
|
const struct action_kw_list *action_kwl; /* used with TH_EX_CTX_ACTION */
|
|
const struct flt_conf *flt_conf; /* used with TH_EX_CTX_FLTCONF */
|
|
const struct mux_ops *mux_ops; /* used with TH_EX_CTX_MUX */
|
|
const struct task *(*task)(struct task *, void *, unsigned int); /* used with TH_EX_CTX_TASK */
|
|
const struct applet *applet; /* used with TH_EX_CTX_APPLET */
|
|
const struct cli_kw_list *cli_kwl; /* used with TH_EX_CTX_CLI_KWL */
|
|
};
|
|
};
|
|
|
|
/* Thread group information. This defines a base and a count of global thread
|
|
* IDs which belong to it, and which can be looked up into thread_info/ctx. It
|
|
* is set up during parsing and is stable during operation. Thread groups start
|
|
* at 1 so tgroup[0] describes thread group 1.
|
|
*/
|
|
struct tgroup_info {
|
|
ulong threads_enabled; /* mask of threads enabled in this group */
|
|
uint base; /* first thread in this group */
|
|
uint count; /* number of threads in this group */
|
|
ulong tgid_bit; /* bit corresponding to the tgroup ID */
|
|
void *(*start)(void *); /* startup function common to all threads */
|
|
|
|
/* pad to cache line (64B) */
|
|
char __pad[0]; /* unused except to check remaining room */
|
|
char __end[0] THREAD_ALIGNED();
|
|
};
|
|
|
|
/* This structure describes the group-specific context (e.g. active threads
|
|
* etc). It uses one cache line per thread to limit false sharing.
|
|
*/
|
|
struct tgroup_ctx {
|
|
ulong threads_harmless; /* mask of threads that are not modifying anything */
|
|
ulong threads_idle; /* mask of threads idling in the poller */
|
|
ulong stopping_threads; /* mask of threads currently stopping */
|
|
|
|
struct eb_root timers; /* wait queue (sorted timers tree, global, accessed under wq_lock) */
|
|
|
|
uint niced_tasks; /* number of niced tasks in this group's run queues */
|
|
|
|
/* pad to cache line (64B) */
|
|
char __pad[0]; /* unused except to check remaining room */
|
|
char __end[0] THREAD_ALIGNED();
|
|
};
|
|
|
|
/* This structure describes all the per-thread info we need. When threads are
|
|
* disabled, it contains the same info for the single running thread. This is
|
|
* stable across all of a thread's life, and is being pointed to by the
|
|
* thread-local "ti" pointer.
|
|
*/
|
|
struct thread_info {
|
|
const struct tgroup_info *tg; /* config of the thread-group this thread belongs to */
|
|
struct tgroup_ctx *tg_ctx; /* context of the thread-group this thread belongs to */
|
|
uint tid, ltid; /* process-wide and group-wide thread ID (start at 0) */
|
|
ulong ltid_bit; /* bit masks for the tid/ltid */
|
|
uint tgid; /* ID of the thread group this thread belongs to (starts at 1; 0=unset) */
|
|
uint ring_queue; /* queue number for the rings */
|
|
|
|
ullong pth_id; /* the pthread_t cast to a ullong */
|
|
void *stack_top; /* the top of the stack when entering the thread */
|
|
|
|
/* pad to cache line (64B) */
|
|
char __pad[0]; /* unused except to check remaining room */
|
|
char __end[0] THREAD_ALIGNED();
|
|
};
|
|
|
|
/* This structure describes all the per-thread context we need. This is
|
|
* essentially the scheduler-specific stuff and a few important per-thread
|
|
* lists that need to be thread-local. We take care of splitting this into
|
|
* separate cache lines.
|
|
*/
|
|
struct thread_ctx {
|
|
// first and second cache lines on 64 bits: thread-local operations only.
|
|
struct eb_root timers; /* tree constituting the per-thread wait queue */
|
|
struct eb_root rqueue; /* tree constituting the per-thread run queue */
|
|
struct task *current; /* current task (not tasklet) */
|
|
int current_queue; /* points to current tasklet list being run, -1 if none */
|
|
unsigned int nb_tasks; /* number of tasks allocated on this thread */
|
|
uint8_t tl_class_mask; /* bit mask of non-empty tasklets classes */
|
|
uint8_t bufq_map; /* one bit per non-empty buffer_wq */
|
|
uint8_t trc_disable_ctr; /* cumulative counter to temporarily disable tracing */
|
|
uint8_t lock_level; /* locking level for that thread. 0=unlocked, +128=isolated. */
|
|
unsigned int nb_rhttp_conns; /* count of current conns used for active reverse HTTP */
|
|
struct sched_activity *sched_profile_entry; /* profile entry in use by the current task/tasklet, only if sched_wake_date>0 */
|
|
|
|
ALWAYS_ALIGN(2*sizeof(void*));
|
|
struct list buffer_wq[DYNBUF_NBQ]; /* buffer waiters, 4 criticality-based queues */
|
|
struct list pool_lru_head; /* oldest objects in thread-local pool caches */
|
|
struct list streams; /* list of streams attached to this thread */
|
|
struct list quic_conns_fe; /* list of active FE quic-conns attached to this thread */
|
|
struct list quic_conns_be; /* list of active BE quic-conns attached to this thread */
|
|
struct list quic_conns_clo; /* list of closing quic-conns attached to this thread */
|
|
struct list queued_checks; /* checks waiting for a connection slot */
|
|
struct list tasklets[TL_CLASSES]; /* tasklets (and/or tasks) to run, by class */
|
|
|
|
void **emergency_bufs; /* array of buffers allocated at boot. Next free one is [emergency_bufs_left-1] */
|
|
uint emergency_bufs_left; /* number of emergency buffers left in magic_bufs[] */
|
|
|
|
uint32_t sched_wake_date; /* current task/tasklet's wake date in 32-bit ns or 0 if not supported */
|
|
uint64_t sched_call_date; /* current task/tasklet's call date in ns */
|
|
uint64_t lock_wait_total; /* total time in ns spent waiting for a lock (task prof) */
|
|
uint64_t mem_wait_total; /* total time in ns spent allocating/freeing memory (task prof) */
|
|
uint64_t lock_start_date; /* date when first locked was obtained (task prof) */
|
|
uint64_t locked_total; /* total time in ns spent with at least one lock held (task prof) */
|
|
|
|
uint64_t prev_mono_time; /* previous system wide monotonic time (leaving poll) */
|
|
uint64_t curr_mono_time; /* latest system wide monotonic time (leaving poll) */
|
|
|
|
ulong lock_history; /* history of used locks, see thread.h for more details */
|
|
struct thread_exec_ctx exec_ctx; /* current execution context when known, or NULL */
|
|
|
|
// fourth cache line here on 64 bits: accessed mostly using atomic ops
|
|
ALWAYS_ALIGN(64);
|
|
struct mt_list shared_tasklet_list; /* Tasklet to be run, woken up by other threads */
|
|
unsigned int rqueue_ticks; /* Insertion counter for the run queue */
|
|
unsigned int rq_total; /* total size of the run queue, prio_tree + tasklets */
|
|
int tasks_in_list; /* Number of tasks in the per-thread tasklets list */
|
|
uint idle_pct; /* idle to total ratio over last sample (percent) */
|
|
uint flags; /* thread flags, TH_FL_*, atomic! */
|
|
uint active_checks; /* number of active health checks on this thread, incl migrated */
|
|
|
|
uint64_t prev_cpu_time; /* previous per thread CPU time */
|
|
|
|
struct eb_root rqueue_shared; /* run queue fed by other threads */
|
|
__decl_thread(HA_SPINLOCK_T rqsh_lock); /* lock protecting the shared runqueue */
|
|
|
|
struct freq_ctr out_32bps; /* #of 32-byte blocks emitted per second */
|
|
uint running_checks; /* number of health checks currently running on this thread */
|
|
|
|
unsigned long long out_bytes; /* total #of bytes emitted */
|
|
unsigned long long spliced_out_bytes; /* total #of bytes emitted though a kernel pipe */
|
|
struct buffer *thread_dump_buffer; /* NULL out of dump, 0x02=to alloc, valid during a dump, |0x01 once done */
|
|
struct buffer *last_dump_buffer; /* Copy of last buffer used for a dump; may be NULL or invalid; for post-mortem only */
|
|
unsigned long long total_streams; /* Total number of streams created on this thread */
|
|
unsigned int stream_cnt; /* Number of streams attached to this thread */
|
|
unsigned int rq_tot_peak; /* total run queue size last call */
|
|
|
|
// around 68 bytes here for shared variables
|
|
|
|
ALWAYS_ALIGN(128);
|
|
};
|
|
|
|
|
|
#endif /* _HAPROXY_TINFO_T_H */
|