Skip to content

M
MariaDB
Commit 21326513 authored by Vladislav Vaintroub's avatar Vladislav Vaintroub
Browse files
Options

Remove some trailing whitespaces.

parent 5bf9e0f8
Hide whitespace changes
Inline Side-by-side
Showing with 205 additions and 212 deletions
sql/threadpool.h
View file @ 21326513
......@@ -138,7 +138,7 @@ struct TP_pool
#ifdef _WIN32
struct TP_pool_win:TP_pool
{
TP_pool_win();
TP_pool_win();
virtual int init();
virtual ~TP_pool_win();
virtual TP_connection *new_connection(CONNECT *c);
......
sql/threadpool_common.cc
View file @ 21326513
......@@ -60,24 +60,24 @@ static inline TP_connection *get_TP_connection(THD *thd)
/*
Worker threads contexts, and THD contexts.
=========================================
Both worker threads and connections have their sets of thread local variables
At the moment it is mysys_var (this has specific data for dbug, my_error and
Both worker threads and connections have their sets of thread local variables
At the moment it is mysys_var (this has specific data for dbug, my_error and
similar goodies), and PSI per-client structure.
Whenever query is executed following needs to be done:
1. Save worker thread context.
2. Change TLS variables to connection specific ones using thread_attach(THD*).
This function does some additional work , e.g setting up
This function does some additional work , e.g setting up
thread_stack/thread_ends_here pointers.
3. Process query
4. Restore worker thread context.
Connection login and termination follows similar schema w.r.t saving and
restoring contexts.
Connection login and termination follows similar schema w.r.t saving and
restoring contexts.
For both worker thread, and for the connection, mysys variables are created
For both worker thread, and for the connection, mysys variables are created
using my_thread_init() and freed with my_thread_end().
*/
......@@ -154,7 +154,7 @@ static void thread_attach(THD* thd)
}
/*
Determine connection priority , using current
Determine connection priority , using current
transaction state and 'threadpool_priority' variable value.
*/
static TP_PRIORITY get_priority(TP_connection *c)
......@@ -289,7 +289,7 @@ static void threadpool_remove_connection(THD *thd)
delete thd;
/*
Free resources associated with this connection:
Free resources associated with this connection:
mysys thread_var and PSI thread.
*/
my_thread_end();
......@@ -323,8 +323,8 @@ static int threadpool_process_request(THD *thd)
if (thd->killed >= KILL_CONNECTION)
{
/*
killed flag was set by timeout handler
/*
killed flag was set by timeout handler
or KILL command. Return error.
*/
retval= 1;
......
sql/threadpool_generic.cc
View file @ 21326513
......@@ -83,7 +83,7 @@ static PSI_thread_info thread_list[] =
{&key_timer_thread, "timer_thread", PSI_FLAG_GLOBAL}
};
/* Macro to simplify performance schema registration */
/* Macro to simplify performance schema registration */
#define PSI_register(X) \
if(PSI_server) PSI_server->register_ ## X("threadpool", X ## _list, array_elements(X ## _list))
#else
......@@ -126,48 +126,47 @@ static void print_pool_blocked_message(bool);
/**
Asynchronous network IO.
We use native edge-triggered network IO multiplexing facility.
We use native edge-triggered network IO multiplexing facility.
This maps to different APIs on different Unixes.
Supported are currently Linux with epoll, Solaris with event ports,
OSX and BSD with kevent, Windows with IOCP. All those API's are used with one-shot flags
(the event is signalled once client has written something into the socket,
(the event is signalled once client has written something into the socket,
then socket is removed from the "poll-set" until the command is finished,
and we need to re-arm/re-register socket)
No implementation for poll/select is currently provided.
The API closely resembles all of the above mentioned platform APIs
and consists of following functions.
The API closely resembles all of the above mentioned platform APIs
and consists of following functions.
- io_poll_create()
Creates an io_poll descriptor
Creates an io_poll descriptor
On Linux: epoll_create()
- io_poll_associate_fd(int poll_fd, TP_file_handle fd, void *data, void *opt)
Associate file descriptor with io poll descriptor
Associate file descriptor with io poll descriptor
On Linux : epoll_ctl(..EPOLL_CTL_ADD))
- io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
Associate file descriptor with io poll descriptor
Associate file descriptor with io poll descriptor
On Linux: epoll_ctl(..EPOLL_CTL_DEL)
- io_poll_start_read(int poll_fd,int fd, void *data, void *opt)
The same as io_poll_associate_fd(), but cannot be used before
The same as io_poll_associate_fd(), but cannot be used before
io_poll_associate_fd() was called.
On Linux : epoll_ctl(..EPOLL_CTL_MOD)
- io_poll_wait (TP_file_handle pollfd, native_event *native_events, int maxevents,
- io_poll_wait (TP_file_handle pollfd, native_event *native_events, int maxevents,
int timeout_ms)
wait until one or more descriptors added with io_poll_associate_fd()
or io_poll_start_read() becomes readable. Data associated with
descriptors can be retrieved from native_events array, using
wait until one or more descriptors added with io_poll_associate_fd()
or io_poll_start_read() becomes readable. Data associated with
descriptors can be retrieved from native_events array, using
native_event_get_userdata() function.
On Linux: epoll_wait()
*/
......@@ -199,7 +198,7 @@ int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *data, voi
ev.data.u64= 0; /* Keep valgrind happy */
ev.data.ptr= data;
ev.events= EPOLLIN|EPOLLET|EPOLLERR|EPOLLRDHUP|EPOLLONESHOT;
return epoll_ctl(pollfd, EPOLL_CTL_MOD, fd, &ev);
return epoll_ctl(pollfd, EPOLL_CTL_MOD, fd, &ev);
}
int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
......@@ -214,11 +213,11 @@ int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
NOTE - in case of EINTR, it restarts with original timeout. Since we use
either infinite or 0 timeouts, this is not critical
*/
int io_poll_wait(TP_file_handle pollfd, native_event *native_events, int maxevents,
int io_poll_wait(TP_file_handle pollfd, native_event *native_events, int maxevents,
int timeout_ms)
{
int ret;
do
do
{
ret = epoll_wait(pollfd, native_events, maxevents, timeout_ms);
}
......@@ -234,9 +233,9 @@ static void *native_event_get_userdata(native_event *event)
#elif defined(HAVE_KQUEUE)
/*
/*
NetBSD is incompatible with other BSDs , last parameter in EV_SET macro
(udata, user data) needs to be intptr_t, whereas it needs to be void*
(udata, user data) needs to be intptr_t, whereas it needs to be void*
everywhere else.
*/
......@@ -255,18 +254,18 @@ TP_file_handle io_poll_create()
int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *data,void *)
{
struct kevent ke;
MY_EV_SET(&ke, fd, EVFILT_READ, EV_ADD|EV_ONESHOT,
MY_EV_SET(&ke, fd, EVFILT_READ, EV_ADD|EV_ONESHOT,
0, 0, data);
return kevent(pollfd, &ke, 1, 0, 0, 0);
return kevent(pollfd, &ke, 1, 0, 0, 0);
}
int io_poll_associate_fd(TP_file_handle pollfd, TP_file_handle fd, void *data,void *)
{
struct kevent ke;
MY_EV_SET(&ke, fd, EVFILT_READ, EV_ADD|EV_ONESHOT,
MY_EV_SET(&ke, fd, EVFILT_READ, EV_ADD|EV_ONESHOT,
0, 0, data);
return io_poll_start_read(pollfd,fd, data, 0);
return io_poll_start_read(pollfd,fd, data, 0);
}
......@@ -289,7 +288,7 @@ int io_poll_wait(TP_file_handle pollfd, struct kevent *events, int maxevents, in
}
do
{
ret= kevent(pollfd, 0, 0, events, maxevents,
ret= kevent(pollfd, 0, 0, events, maxevents,
(timeout_ms >= 0)?&ts:NULL);
}
while (ret == -1 && errno == EINTR);
......@@ -388,9 +387,9 @@ int io_poll_start_read(TP_file_handle pollfd, TP_file_handle fd, void *, void *o
static int io_poll_associate_fd(TP_file_handle pollfd, TP_file_handle fd, void *data, void *opt)
{
HANDLE h= CreateIoCompletionPort(fd, pollfd, (ULONG_PTR)data, 0);
if (!h)
if (!h)
return -1;
return io_poll_start_read(pollfd,fd, 0, opt);
return io_poll_start_read(pollfd,fd, 0, opt);
}
......@@ -433,9 +432,9 @@ int io_poll_disassociate_fd(TP_file_handle pollfd, TP_file_handle fd)
int io_poll_wait(TP_file_handle pollfd, native_event *events, int maxevents, int timeout_ms)
{
ULONG n;
BOOL ok = GetQueuedCompletionStatusEx(pollfd, events,
BOOL ok = GetQueuedCompletionStatusEx(pollfd, events,
maxevents, &n, timeout_ms, FALSE);
return ok ? (int)n : -1;
}
......@@ -460,7 +459,7 @@ static TP_connection_generic *queue_get(thread_group_t *thread_group)
if (c)
DBUG_RETURN(c);
}
DBUG_RETURN(0);
DBUG_RETURN(0);
}
static TP_connection_generic* queue_get(thread_group_t* group, operation_origin origin)
......@@ -503,8 +502,8 @@ static void queue_put(thread_group_t *thread_group, native_event *ev, int cnt)
}
}
/*
Handle wait timeout :
/*
Handle wait timeout :
Find connections that have been idle for too long and kill them.
Also, recalculate time when next timeout check should run.
*/
......@@ -530,16 +529,16 @@ static my_bool timeout_check(THD *thd, pool_timer_t *timer)
}
/*
Timer thread.
/*
Timer thread.
Periodically, check if one of the thread groups is stalled. Stalls happen if
events are not being dequeued from the queue, or from the network, Primary
reason for stall can be a lengthy executing non-blocking request. It could
also happen that thread is waiting but wait_begin/wait_end is forgotten by
storage engine. Timer thread will create a new thread in group in case of
events are not being dequeued from the queue, or from the network, Primary
reason for stall can be a lengthy executing non-blocking request. It could
also happen that thread is waiting but wait_begin/wait_end is forgotten by
storage engine. Timer thread will create a new thread in group in case of
a stall.
Besides checking for stalls, timer thread is also responsible for terminating
clients that have been idle for longer than wait_timeout seconds.
......@@ -574,14 +573,14 @@ static void* timer_thread(void *param)
if (err == ETIMEDOUT)
{
timer->current_microtime= microsecond_interval_timer();
/* Check stalls in thread groups */
for (i= 0; i < threadpool_max_size; i++)
{
if(all_groups[i].connection_count)
check_stall(&all_groups[i]);
}
/* Check if any client exceeded wait_timeout */
if (timer->next_timeout_check.load(std::memory_order_relaxed) <=
timer->current_microtime)
......@@ -624,9 +623,9 @@ void check_stall(thread_group_t *thread_group)
}
/*
Check if listener is present. If not, check whether any IO
events were dequeued since last time. If not, this means
listener is either in tight loop or thd_wait_begin()
Check if listener is present. If not, check whether any IO
events were dequeued since last time. If not, this means
listener is either in tight loop or thd_wait_begin()
was forgotten. Create a new worker(it will make itself listener).
*/
if (!thread_group->listener && !thread_group->io_event_count)
......@@ -635,16 +634,16 @@ void check_stall(thread_group_t *thread_group)
mysql_mutex_unlock(&thread_group->mutex);
return;
}
/* Reset io event count */
thread_group->io_event_count= 0;
/*
/*
Check whether requests from the workqueue are being dequeued.
The stall detection and resolution works as follows:
1. There is a counter thread_group->queue_event_count for the number of
1. There is a counter thread_group->queue_event_count for the number of
events removed from the queue. Timer resets the counter to 0 on each run.
2. Timer determines stall if this counter remains 0 since last check
and the queue is not empty.
......@@ -655,13 +654,13 @@ void check_stall(thread_group_t *thread_group)
Q : Will this handling lead to an unbound growth of threads, if queue
stalls permanently?
A : No. If queue stalls permanently, it is an indication for many very long
simultaneous queries. The maximum number of simultanoues queries is
simultaneous queries. The maximum number of simultanoues queries is
max_connections, further we have threadpool_max_threads limit, upon which no
worker threads are created. So in case there is a flood of very long
worker threads are created. So in case there is a flood of very long
queries, threadpool would slowly approach thread-per-connection behavior.
NOTE:
If long queries never wait, creation of the new threads is done by timer,
so it is slower than in real thread-per-connection. However if long queries
so it is slower than in real thread-per-connection. However if long queries
do wait and indicate that via thd_wait_begin/end callbacks, thread creation
will be faster.
*/
......@@ -671,10 +670,10 @@ void check_stall(thread_group_t *thread_group)
TP_INCREMENT_GROUP_COUNTER(thread_group,stalls);
wake_or_create_thread(thread_group,true);
}
/* Reset queue event count */
thread_group->queue_event_count= 0;
mysql_mutex_unlock(&thread_group->mutex);
}
......@@ -706,10 +705,10 @@ static void stop_timer(pool_timer_t *timer)
/**
Poll for socket events and distribute them to worker threads
In many case current thread will handle single event itself.
@return a ready connection, or NULL on shutdown
*/
static TP_connection_generic * listener(worker_thread_t *current_thread,
static TP_connection_generic * listener(worker_thread_t *current_thread,
thread_group_t *thread_group)
{
DBUG_ENTER("listener");
......@@ -719,10 +718,10 @@ static TP_connection_generic * listener(worker_thread_t *current_thread,
{
native_event ev[MAX_EVENTS];
int cnt;
if (thread_group->shutdown)
break;
cnt = io_poll_wait(thread_group->pollfd, ev, MAX_EVENTS, -1);
TP_INCREMENT_GROUP_COUNTER(thread_group, polls[(int)operation_origin::LISTENER]);
if (cnt <=0)
......@@ -730,7 +729,7 @@ static TP_connection_generic * listener(worker_thread_t *current_thread,
DBUG_ASSERT(thread_group->shutdown);
break;
}
mysql_mutex_lock(&thread_group->mutex);
if (thread_group->shutdown)
......@@ -738,53 +737,52 @@ static TP_connection_generic * listener(worker_thread_t *current_thread,
mysql_mutex_unlock(&thread_group->mutex);
break;
}
thread_group->io_event_count += cnt;
/*
thread_group->io_event_count += cnt;
/*
We got some network events and need to make decisions : whether
listener hould handle events and whether or not any wake worker
threads so they can handle events.
Q1 : Should listener handle an event itself, or put all events into
Q1 : Should listener handle an event itself, or put all events into
queue and let workers handle the events?
Solution :
Generally, listener that handles events itself is preferable. We do not
want listener thread to change its state from waiting to running too
Generally, listener that handles events itself is preferable. We do not
want listener thread to change its state from waiting to running too
often, Since listener has just woken from poll, it better uses its time
slice and does some work. Besides, not handling events means they go to
the queue, and often to wake another worker must wake up to handle the
event. This is not good, as we want to avoid wakeups.
The downside of listener that also handles queries is that we can
potentially leave thread group for long time not picking the new
potentially leave thread group for long time not picking the new
network events. It is not a major problem, because this stall will be
detected sooner or later by the timer thread. Still, relying on timer
is not always good, because it may "tick" too slow (large timer_interval)
We use following strategy to solve this problem - if queue was not empty
we suspect flood of network events and listener stays, Otherwise, it
we suspect flood of network events and listener stays, Otherwise, it
handles a query.
Q2: If queue is not empty, how many workers to wake?
Solution:
We generally try to keep one thread per group active (threads handling
queries are considered active, unless they stuck in inside some "wait")
Thus, we will wake only one worker, and only if there is not active
threads currently,and listener is not going to handle a query. When we
don't wake, we hope that currently active threads will finish fast and
We generally try to keep one thread per group active (threads handling
queries are considered active, unless they stuck in inside some "wait")
Thus, we will wake only one worker, and only if there is not active
threads currently,and listener is not going to handle a query. When we
don't wake, we hope that currently active threads will finish fast and
handle the queue. If this does not happen, timer thread will detect stall
and wake a worker.
NOTE: Currently nothing is done to detect or prevent long queuing times.
A solution for the future would be to give up "one active thread per
group" principle, if events stay in the queue for too long, and just wake
NOTE: Currently nothing is done to detect or prevent long queuing times.
A solution for the future would be to give up "one active thread per
group" principle, if events stay in the queue for too long, and just wake
more workers.
*/
bool listener_picks_event=is_queue_empty(thread_group) && !threadpool_dedicated_listener;
queue_put(thread_group, ev, cnt);
if (listener_picks_event)
......@@ -800,19 +798,19 @@ static TP_connection_generic * listener(worker_thread_t *current_thread,
/* We added some work items to queue, now wake a worker. */
if(wake_thread(thread_group, false))
{
/*
/*
Wake failed, hence groups has no idle threads. Now check if there are
any threads in the group except listener.
*/
*/
if(thread_group->thread_count == 1)
{
/*
Currently there is no worker thread in the group, as indicated by
thread_count == 1 (this means listener is the only one thread in
thread_count == 1 (this means listener is the only one thread in
the group).
The queue is not empty, and listener is not going to handle
events. In order to drain the queue, we create a worker here.
Alternatively, we could just rely on timer to detect stall, and
Alternatively, we could just rely on timer to detect stall, and
create thread, but waiting for timer would be an inefficient and
pointless delay.
*/
......@@ -827,7 +825,7 @@ static TP_connection_generic * listener(worker_thread_t *current_thread,
}
/**
Adjust thread counters in group or global
Adjust thread counters in group or global
whenever thread is created or is about to exit
@param thread_group
......@@ -845,8 +843,8 @@ static void add_thread_count(thread_group_t *thread_group, int32 count)
/**
Creates a new worker thread.
thread_mutex must be held when calling this function
Creates a new worker thread.
thread_mutex must be held when calling this function
NOTE: in rare cases, the number of threads can exceed
threadpool_max_threads, because we need at least 2 threads
......@@ -858,7 +856,7 @@ static int create_worker(thread_group_t *thread_group, bool due_to_stall)
pthread_t thread_id;
bool max_threads_reached= false;
int err;
DBUG_ENTER("create_worker");
if (tp_stats.num_worker_threads >= threadpool_max_threads
&& thread_group->thread_count >= 2)
......@@ -868,8 +866,7 @@ static int create_worker(thread_group_t *thread_group, bool due_to_stall)
goto end;
}
err= mysql_thread_create(key_worker_thread, &thread_id,
err= mysql_thread_create(key_worker_thread, &thread_id,
thread_group->pthread_attr, worker_main, thread_group);
if (!err)
{
......@@ -892,18 +889,18 @@ static int create_worker(thread_group_t *thread_group, bool due_to_stall)
print_pool_blocked_message(max_threads_reached);
else
pool_block_start= 0; /* Reset pool blocked timer, if it was set */
DBUG_RETURN(err);
}
/**
Calculate microseconds throttling delay for thread creation.
The value depends on how many threads are already in the group:
small number of threads means no delay, the more threads the larger
the delay.
The actual values were not calculated using any scientific methods.
They just look right, and behave well in practice.
*/
......@@ -913,7 +910,7 @@ static int create_worker(thread_group_t *thread_group, bool due_to_stall)
static ulonglong microsecond_throttling_interval(thread_group_t *thread_group)
{
int count= thread_group->thread_count;
if (count < 1+ (int)threadpool_oversubscribe)
return 0;
......@@ -928,15 +925,15 @@ static ulonglong microsecond_throttling_interval(thread_group_t *thread_group)
/**
Wakes a worker thread, or creates a new one.
Wakes a worker thread, or creates a new one.
Worker creation is throttled, so we avoid too many threads
to be created during the short time.
*/
static int wake_or_create_thread(thread_group_t *thread_group, bool due_to_stall)
{
DBUG_ENTER("wake_or_create_thread");
if (thread_group->shutdown)
DBUG_RETURN(0);
......@@ -948,13 +945,13 @@ static int wake_or_create_thread(thread_group_t *thread_group, bool due_to_stall
if (thread_group->thread_count > thread_group->connection_count)
DBUG_RETURN(-1);
if (thread_group->active_thread_count == 0)
{
/*
We're better off creating a new thread here with no delay, either there
are no workers at all, or they all are all blocking and there was no
idle thread to wakeup. Smells like a potential deadlock or very slowly
We're better off creating a new thread here with no delay, either there
are no workers at all, or they all are all blocking and there was no
idle thread to wakeup. Smells like a potential deadlock or very slowly
executing requests, e.g sleeps or user locks.
*/
DBUG_RETURN(create_worker(thread_group, due_to_stall));
......@@ -963,8 +960,8 @@ static int wake_or_create_thread(thread_group_t *thread_group, bool due_to_stall
ulonglong now = microsecond_interval_timer();
ulonglong time_since_last_thread_created =
(now - thread_group->last_thread_creation_time);
/* Throttle thread creation. */
/* Throttle thread creation. */
if (time_since_last_thread_created >
microsecond_throttling_interval(thread_group))
{
......@@ -1036,7 +1033,7 @@ static int wake_thread(thread_group_t *thread_group,bool due_to_stall)
DBUG_RETURN(1); /* no thread in waiter list => missed wakeup */
}
/*
/*
Wake listener thread (during shutdown)
Self-pipe trick is used in most cases,except IOCP.
*/
......@@ -1065,8 +1062,8 @@ static int wake_listener(thread_group_t *thread_group)
/**
Initiate shutdown for thread group.
The shutdown is asynchronous, we only care to wake all threads in here, so
they can finish. We do not wait here until threads terminate. Final cleanup
The shutdown is asynchronous, we only care to wake all threads in here, so
they can finish. We do not wait here until threads terminate. Final cleanup
of the group (thread_group_destroy) will be done by the last exiting threads.
*/
......@@ -1075,32 +1072,32 @@ static void thread_group_close(thread_group_t *thread_group)
DBUG_ENTER("thread_group_close");
mysql_mutex_lock(&thread_group->mutex);
if (thread_group->thread_count == 0)
if (thread_group->thread_count == 0)
{
mysql_mutex_unlock(&thread_group->mutex);
thread_group_destroy(thread_group);
DBUG_VOID_RETURN;
}
thread_group->shutdown= true;
thread_group->shutdown= true;
thread_group->listener= NULL;
wake_listener(thread_group);
/* Wake all workers. */
while(wake_thread(thread_group, false) == 0)
{
while(wake_thread(thread_group, false) == 0)
{
}
mysql_mutex_unlock(&thread_group->mutex);
DBUG_VOID_RETURN;
}
/*
/*
Add work to the queue. Maybe wake a worker if they all sleep.
Currently, this function is only used when new connections need to
perform login (this is done in worker threads).
......@@ -1120,39 +1117,39 @@ static void queue_put(thread_group_t *thread_group, TP_connection_generic *conne
}
/*
Prevent too many threads executing at the same time,if the workload is
/*
Prevent too many threads executing at the same time,if the workload is
not CPU bound.
*/
static bool too_many_threads(thread_group_t *thread_group)
{
return (thread_group->active_thread_count >= 1+(int)threadpool_oversubscribe
return (thread_group->active_thread_count >= 1+(int)threadpool_oversubscribe
&& !thread_group->stalled);
}
/**
Retrieve a connection with pending event.
Pending event in our case means that there is either a pending login request
Pending event in our case means that there is either a pending login request
(if connection is not yet logged in), or there are unread bytes on the socket.
If there are no pending events currently, thread will wait.
If there are no pending events currently, thread will wait.
If timeout specified in abstime parameter passes, the function returns NULL.
@param current_thread - current worker thread
@param thread_group - current thread group
@param abstime - absolute wait timeout
@return
connection with pending event.
connection with pending event.
NULL is returned if timeout has expired,or on shutdown.
*/
TP_connection_generic *get_event(worker_thread_t *current_thread,
TP_connection_generic *get_event(worker_thread_t *current_thread,
thread_group_t *thread_group, struct timespec *abstime)
{
{
DBUG_ENTER("get_event");
TP_connection_generic *connection = NULL;
......@@ -1160,10 +1157,10 @@ TP_connection_generic *get_event(worker_thread_t *current_thread,
mysql_mutex_lock(&thread_group->mutex);
DBUG_ASSERT(thread_group->active_thread_count >= 0);
for(;;)
for(;;)
{
int err=0;
bool oversubscribed = too_many_threads(thread_group);
bool oversubscribed = too_many_threads(thread_group);
if (thread_group->shutdown)
break;
......@@ -1192,10 +1189,10 @@ TP_connection_generic *get_event(worker_thread_t *current_thread,
thread_group->listener= NULL;
break;
}
/*
Last thing we try before going to sleep is to
/*
Last thing we try before going to sleep is to
non-blocking event poll, i.e with timeout = 0.
If this returns events, pick one
*/
......@@ -1213,20 +1210,20 @@ TP_connection_generic *get_event(worker_thread_t *current_thread,
}
/* And now, finally sleep */
/* And now, finally sleep */
current_thread->woken = false; /* wake() sets this to true */
/*
/*
Add current thread to the head of the waiting list and wait.
It is important to add thread to the head rather than tail
as it ensures LIFO wakeup order (hot caches, working inactivity timeout)
*/
thread_group->waiting_threads.push_front(current_thread);
thread_group->active_thread_count--;
if (abstime)
{
err = mysql_cond_timedwait(&current_thread->cond, &thread_group->mutex,
err = mysql_cond_timedwait(&current_thread->cond, &thread_group->mutex,
abstime);
}
else
......@@ -1234,7 +1231,7 @@ TP_connection_generic *get_event(worker_thread_t *current_thread,
err = mysql_cond_wait(&current_thread->cond, &thread_group->mutex);
}
thread_group->active_thread_count++;
if (!current_thread->woken)
{
/*
......@@ -1252,14 +1249,14 @@ TP_connection_generic *get_event(worker_thread_t *current_thread,
thread_group->stalled= false;
mysql_mutex_unlock(&thread_group->mutex);
DBUG_RETURN(connection);
}
/**
Tells the pool that worker starts waiting on IO, lock, condition,
Tells the pool that worker starts waiting on IO, lock, condition,
sleep() or similar.
*/
......@@ -1268,20 +1265,20 @@ void wait_begin(thread_group_t *thread_group)
DBUG_ENTER("wait_begin");
mysql_mutex_lock(&thread_group->mutex);
thread_group->active_thread_count--;
DBUG_ASSERT(thread_group->active_thread_count >=0);
DBUG_ASSERT(thread_group->connection_count > 0);
if ((thread_group->active_thread_count == 0) &&
if ((thread_group->active_thread_count == 0) &&
(!is_queue_empty(thread_group) || !thread_group->listener))
{
/*
Group might stall while this thread waits, thus wake
/*
Group might stall while this thread waits, thus wake
or create a worker to prevent stall.
*/
wake_or_create_thread(thread_group);
}
mysql_mutex_unlock(&thread_group->mutex);
DBUG_VOID_RETURN;
}
......@@ -1300,15 +1297,13 @@ void wait_end(thread_group_t *thread_group)
}
TP_connection * TP_pool_generic::new_connection(CONNECT *c)
{
return new (std::nothrow) TP_connection_generic(c);
}
/**
Add a new connection to thread pool..
Add a new connection to thread pool
*/
void TP_pool_generic::add(TP_connection *c)
......@@ -1318,7 +1313,7 @@ void TP_pool_generic::add(TP_connection *c)
TP_connection_generic *connection=(TP_connection_generic *)c;
thread_group_t *thread_group= connection->thread_group;
/*
Add connection to the work queue.Actual logon
Add connection to the work queue.Actual logon
will be done by a worker thread.
*/
mysql_mutex_lock(&thread_group->mutex);
......@@ -1349,8 +1344,8 @@ void TP_connection_generic::wait_begin(int type)
MySQL scheduler callback: wait end
*/
void TP_connection_generic::wait_end()
{
void TP_connection_generic::wait_end()
{
DBUG_ENTER("wait_end");
DBUG_ASSERT(waiting);
waiting--;
......@@ -1424,17 +1419,17 @@ TP_connection_generic::~TP_connection_generic()
}
/**
Set wait timeout for connection.
Set wait timeout for connection.
*/
void TP_connection_generic::set_io_timeout(int timeout_sec)
{
DBUG_ENTER("set_wait_timeout");
/*
/*
Calculate wait deadline for this connection.
Instead of using microsecond_interval_timer() which has a syscall
overhead, use pool_timer.current_microtime and take
into account that its value could be off by at most
Instead of using microsecond_interval_timer() which has a syscall
overhead, use pool_timer.current_microtime and take
into account that its value could be off by at most
one tick interval.
*/
......@@ -1448,15 +1443,15 @@ void TP_connection_generic::set_io_timeout(int timeout_sec)
/**
Handle a (rare) special case,where connection needs to
Handle a (rare) special case,where connection needs to
migrate to a different group because group_count has changed
after thread_pool_size setting.
after thread_pool_size setting.
*/
static int change_group(TP_connection_generic *c,
static int change_group(TP_connection_generic *c,
thread_group_t *old_group,
thread_group_t *new_group)
{
{
int ret= 0;
DBUG_ASSERT(c->thread_group == old_group);
......@@ -1470,7 +1465,7 @@ static int change_group(TP_connection_generic *c,
}
c->thread_group->connection_count--;
mysql_mutex_unlock(&old_group->mutex);
/* Add connection to the new group. */
mysql_mutex_lock(&new_group->mutex);
c->thread_group= new_group;
......@@ -1507,15 +1502,15 @@ int TP_connection_generic::start_io()
}
}
/*
Bind to poll descriptor if not yet done.
*/
/*
Bind to poll descriptor if not yet done.
*/
if (!bound_to_poll_descriptor)
{
bound_to_poll_descriptor= true;
return io_poll_associate_fd(thread_group->pollfd, fd, this, OPTIONAL_IO_POLL_READ_PARAM);
}
return io_poll_start_read(thread_group->pollfd, fd, this, OPTIONAL_IO_POLL_READ_PARAM);
}
......@@ -1527,13 +1522,13 @@ int TP_connection_generic::start_io()
static void *worker_main(void *param)
{
worker_thread_t this_thread;
pthread_detach_this_thread();
my_thread_init();
DBUG_ENTER("worker_main");
thread_group_t *thread_group = (thread_group_t *)param;
/* Init per-thread structure */
......@@ -1592,7 +1587,7 @@ int TP_pool_generic::init()
threadpool_started= true;
for (uint i= 0; i < threadpool_max_size; i++)
{
thread_group_init(&all_groups[i], get_connection_attrib());
thread_group_init(&all_groups[i], get_connection_attrib());
}
set_pool_size(threadpool_size);
if(group_count == 0)
......@@ -1604,7 +1599,7 @@ int TP_pool_generic::init()
PSI_register(mutex);
PSI_register(cond);
PSI_register(thread);
pool_timer.tick_interval= threadpool_stall_limit;
start_timer(&pool_timer);
DBUG_RETURN(0);
......@@ -1613,7 +1608,7 @@ int TP_pool_generic::init()
TP_pool_generic::~TP_pool_generic()
{
DBUG_ENTER("tp_end");
if (!threadpool_started)
DBUG_VOID_RETURN;
......@@ -1640,7 +1635,7 @@ static my_bool thd_reset_group(THD* thd, void*)
int TP_pool_generic::set_pool_size(uint size)
{
bool success= true;
for(uint i=0; i< size; i++)
{
thread_group_t *group= &all_groups[i];
......@@ -1653,7 +1648,7 @@ int TP_pool_generic::set_pool_size(uint size)
{
sql_print_error("io_poll_create() failed, errno=%d", errno);
}
}
}
mysql_mutex_unlock(&group->mutex);
if (!success)
{
......@@ -1678,8 +1673,8 @@ int TP_pool_generic::set_stall_limit(uint limit)
/**
Calculate number of idle/waiting threads in the pool.
Sum idle threads over all groups.
Sum idle threads over all groups.
Don't do any locking, it is not required for stats.
*/
......@@ -1696,7 +1691,7 @@ int TP_pool_generic::get_idle_thread_count()
/* Report threadpool problems */
/**
/**
Delay in microseconds, after which "pool blocked" message is printed.
(30 sec == 30 Mio usec)
*/
......@@ -1725,7 +1720,7 @@ static void print_pool_blocked_message(bool max_threads_reached)
{
ulonglong now;
static bool msg_written;
now= microsecond_interval_timer();
if (pool_block_start == 0)
{
......@@ -1733,14 +1728,14 @@ static void print_pool_blocked_message(bool max_threads_reached)
msg_written = false;
return;
}
if (now > pool_block_start + BLOCK_MSG_DELAY && !msg_written)
{
if (max_threads_reached)
sql_print_error(MAX_THREADS_REACHED_MSG);
else
sql_print_error(CREATE_THREAD_ERROR_MSG, my_errno);
sql_print_information("Threadpool has been blocked for %u seconds\n",
(uint)((now- pool_block_start)/1000000));
/* avoid reperated messages for the same blocking situation */
......@@ -1748,6 +1743,4 @@ static void print_pool_blocked_message(bool max_threads_reached)
}
}
#endif /* HAVE_POOL_OF_THREADS */
sql/threadpool_generic.h
View file @ 21326513
......@@ -24,7 +24,7 @@
#ifdef _WIN32
#include <windows.h>
/* AIX may define this, too ?*/
#define HAVE_IOCP
#define HAVE_IOCP
#endif
......
sql/threadpool_win.cc
View file @ 21326513
......@@ -59,10 +59,10 @@ PTP_CALLBACK_ENVIRON get_threadpool_win_callback_environ()
*/
static void CALLBACK timer_callback(PTP_CALLBACK_INSTANCE instance,
static void CALLBACK timer_callback(PTP_CALLBACK_INSTANCE instance,
PVOID context, PTP_TIMER timer);
static void CALLBACK io_completion_callback(PTP_CALLBACK_INSTANCE instance,
static void CALLBACK io_completion_callback(PTP_CALLBACK_INSTANCE instance,
PVOID context, PVOID overlapped, ULONG io_result, ULONG_PTR nbytes, PTP_IO io);
......@@ -128,7 +128,7 @@ void TP_pool_win::add(TP_connection *c)
TP_connection_win::TP_connection_win(CONNECT *c) :
TP_connection(c),
timeout(ULONGLONG_MAX),
timeout(ULONGLONG_MAX),
callback_instance(0),
io(0),
timer(0),
......@@ -218,14 +218,14 @@ int TP_connection_win::start_io()
if (retval == 0 || last_error == ERROR_MORE_DATA)
{
/*
IO successfully finished (synchronously).
If skip_completion_port_on_success is set, we need to handle it right
IO successfully finished (synchronously).
If skip_completion_port_on_success is set, we need to handle it right
here, because completion callback would not be executed by the pool.
*/
if (skip_completion_port_on_success)
{
CancelThreadpoolIo(io);
io_completion_callback(callback_instance, this, &overlapped, last_error,
io_completion_callback(callback_instance, this, &overlapped, last_error,
num_bytes, io);
}
return 0;
......@@ -322,7 +322,7 @@ static void pre_callback(PVOID context, PTP_CALLBACK_INSTANCE instance)
/*
Decrement number of threads when a thread exits .
Decrement number of threads when a thread exits.
On Windows, FlsAlloc() provides the thread destruction callbacks.
*/
static VOID WINAPI thread_destructor(void *data)
......@@ -346,7 +346,7 @@ static inline void tp_callback(PTP_CALLBACK_INSTANCE instance, PVOID context)
/*
Handle read completion/notification.
*/
static VOID CALLBACK io_completion_callback(PTP_CALLBACK_INSTANCE instance,
static VOID CALLBACK io_completion_callback(PTP_CALLBACK_INSTANCE instance,
PVOID context, PVOID overlapped, ULONG io_result, ULONG_PTR nbytes, PTP_IO io)
{
TP_connection_win *c= (TP_connection_win *)context;
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7