Skip to content
GitLab
Menu
Projects
Groups
Snippets
Loading...
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
Menu
Open sidebar
ruanhaishen
redis
Commits
6f4f36c0
Commit
6f4f36c0
authored
Mar 25, 2019
by
antirez
Browse files
Threaded IO: second attempt without signaling conditions.
parent
a2dbd9bd
Changes
2
Hide whitespace changes
Inline
Side-by-side
src/networking.c
View file @
6f4f36c0
...
...
@@ -2480,13 +2480,9 @@ int tio_debug = 0;
#define SERVER_MAX_IO_THREADS 32
pthread_t io_threads[SERVER_MAX_IO_THREADS];
pthread_mutex_t
io_threads_done_mutex
=
PTHREAD_MUTEX_INITIALIZER
;
pthread_cond_t
io_threads_done_cond
=
PTHREAD_COND_INITIALIZER
;
pthread_mutex_t
io_threads_idle_mutex
=
PTHREAD_MUTEX_INITIALIZER
;
pthread_cond_t
io_threads_idle_cond
=
PTHREAD_COND_INITIALIZER
;
pthread_cond_t
io_threads_start_cond
=
PTHREAD_COND_INITIALIZER
;
int
io_threads_done
=
0
;
/* Number of threads that completed the work. */
int
io_threads_idle
=
0
;
/* Number of threads in idle state ready to go. */
pthread_mutex_t io_threads_mutex[SERVER_MAX_IO_THREADS];
_Atomic unsigned long io_threads_pending[SERVER_MAX_IO_THREADS];
int io_threads_active;
list *io_threads_list[SERVER_MAX_IO_THREADS];
void *IOThreadMain(void *myid) {
...
...
@@ -2496,30 +2492,23 @@ void *IOThreadMain(void *myid) {
while(1) {
/* ... Wait for start ... */
pthread_mutex_lock
(
&
io_threads_idle_mutex
);
io_threads_idle
++
;
pthread_cond_signal
(
&
io_threads_idle_cond
);
if
(
tio_debug
)
printf
(
"[%ld] Waiting start...
\n
"
,
id
);
pthread_cond_wait
(
&
io_threads_start_cond
,
&
io_threads_idle_mutex
);
if
(
tio_debug
)
printf
(
"[%ld] Started
\n
"
,
id
);
pthread_mutex_unlock
(
&
io_threads_idle_mutex
);
if
(
tio_debug
)
printf
(
"%d to handle
\n
"
,
(
int
)
listLength
(
io_threads_list
[
id
]));
/* ... Process ... */
listIter
li
;
listNode
*
ln
;
listRewind
(
io_threads_list
[
id
],
&
li
);
while
((
ln
=
listNext
(
&
li
)))
{
client
*
c
=
listNodeValue
(
ln
);
writeToClient
(
c
->
fd
,
c
,
0
);
pthread_mutex_lock(&io_threads_mutex[id]);
if (io_threads_pending[id]) {
if (tio_debug) printf("[%ld] %d to handle\n", id, (int)listLength(io_threads_list[id]));
/* ... Process ... */
listIter li;
listNode *ln;
listRewind(io_threads_list[id],&li);
while((ln = listNext(&li))) {
client *c = listNodeValue(ln);
writeToClient(c->fd,c,0);
io_threads_pending[id]--;
}
listEmpty(io_threads_list[id]);
}
listEmpty
(
io_threads_list
[
id
]);
/* Report success. */
pthread_mutex_lock
(
&
io_threads_done_mutex
);
io_threads_done
++
;
pthread_cond_signal
(
&
io_threads_done_cond
);
pthread_mutex_unlock
(
&
io_threads_done_mutex
);
pthread_mutex_unlock(&io_threads_mutex[id]);
if (tio_debug) printf("[%ld] Done\n", id);
}
}
...
...
@@ -2529,30 +2518,50 @@ void initThreadedIO(void) {
pthread_t tid;
server.io_threads_num = 4;
io_threads_active = 0; /* We start with threads not active. */
for (int i = 0; i < server.io_threads_num; i++) {
pthread_mutex_init(&io_threads_mutex[i],NULL);
io_threads_pending[i] = 0;
io_threads_list[i] = listCreate();
pthread_mutex_lock(&io_threads_mutex[i]); /* Thread will be stopped. */
if (pthread_create(&tid,NULL,IOThreadMain,(void*)(long)i) != 0) {
serverLog(LL_WARNING,"Fatal: Can't initialize IO thread.");
exit(1);
}
io_threads[i] = tid;
io_threads_list
[
i
]
=
listCreate
();
}
}
void startThreadedIO(void) {
if (tio_debug) printf("--- STARTING THREADED IO ---\n");
serverAssert(io_threads_active == 0);
for (int j = 0; j < server.io_threads_num; j++)
pthread_mutex_unlock(&io_threads_mutex[j]);
io_threads_active = 1;
}
void stopThreadedIO(void) {
if (tio_debug) printf("--- STOPPING THREADED IO ---\n");
serverAssert(io_threads_active == 1);
for (int j = 0; j < server.io_threads_num; j++)
pthread_mutex_lock(&io_threads_mutex[j]);
io_threads_active = 0;
}
int handleClientsWithPendingWritesUsingThreads(void) {
int processed = listLength(server.clients_pending_write);
if (processed == 0) return 0; /* Return ASAP if there are no clients. */
if
(
tio_debug
)
printf
(
"%d TOTAL
\n
"
,
processed
);
/* Wait for all threads to be ready. */
pthread_mutex_lock
(
&
io_threads_idle_mutex
);
while
(
io_threads_idle
<
server
.
io_threads_num
)
{
pthread_cond_wait
(
&
io_threads_idle_cond
,
&
io_threads_idle_mutex
);
/* If we have just a few clients to serve, don't use I/O threads, but the
* boring synchronous code. */
if (processed < (server.io_threads_num*2)) {
if (io_threads_active) stopThreadedIO();
return handleClientsWithPendingWrites();
} else {
if (!io_threads_active) startThreadedIO();
}
if
(
tio_debug
)
printf
(
"All threads are idle: %d
\n
"
,
io_threads_idle
);
io_threads_idle
=
0
;
pthread_mutex_unlock
(
&
io_threads_idle_mutex
);
if (tio_debug) printf("%d TOTAL pending clients\n", processed);
/* Distribute the clients across N different lists. */
listIter li;
...
...
@@ -2563,23 +2572,20 @@ int handleClientsWithPendingWritesUsingThreads(void) {
client *c = listNodeValue(ln);
c->flags &= ~CLIENT_PENDING_WRITE;
int target_id = item_id % server.io_threads_num;
pthread_mutex_lock(&io_threads_mutex[target_id]);
listAddNodeTail(io_threads_list[target_id],c);
io_threads_pending[target_id]++;
pthread_mutex_unlock(&io_threads_mutex[target_id]);
item_id++;
}
/* Start all threads. */
if
(
tio_debug
)
printf
(
"Send start condition
\n
"
);
pthread_mutex_lock
(
&
io_threads_done_mutex
);
io_threads_done
=
0
;
pthread_cond_broadcast
(
&
io_threads_start_cond
);
pthread_mutex_unlock
(
&
io_threads_done_mutex
);
/* Wait for all threads to end their work. */
pthread_mutex_lock
(
&
io_threads_done_mutex
);
while
(
io_threads_done
<
server
.
io_threads_num
)
{
pthread_cond_wait
(
&
io_threads_done_cond
,
&
io_threads_done_mutex
);
while(1) {
unsigned long pending = 0;
for (int j = 0; j < server.io_threads_num; j++)
pending += io_threads_pending[j];
if (pending == 0) break;
}
pthread_mutex_unlock
(
&
io_threads_done_mutex
);
if (tio_debug) printf("All threads finshed\n");
/* Run the list of clients again to install the write handler where
...
...
src/server.c
View file @
6f4f36c0
...
...
@@ -2072,8 +2072,6 @@ void beforeSleep(struct aeEventLoop *eventLoop) {
flushAppendOnlyFile
(
0
);
/* Handle writes with pending output buffers. */
/* XXX: Put a condition based on number of waiting clients: if we
* have less than a given number of clients, use non threaded code. */
handleClientsWithPendingWritesUsingThreads
();
/* Close clients that need to be closed asynchronous */
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment