mirror/curl
2
0
Fork 0
mirror of https://github.com/curl/curl.git synced 2024-12-15 06:40:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

multi: remove PENDING + MSGSENT handles from the main linked list

Browse Source 
As they are not driving transfers or any socket activity, the main loop
does not need to iterate over these handles. A performance improvement.

They are instead only held in their own separate lists.

'data->multi' is kept a pointer to the multi handle as long as the easy
handle is actually part of it even when the handle is moved to the
pending/msgsent lists. It needs to know which multi handle it belongs
to, if for example curl_easy_cleanup() is called before the handle is
removed from the multi handle.

Alll 'data->multi' pointers of handles still part of the multi handle
gets cleared by curl_multi_cleanup() which "orphans" all previously
attached easy handles.

This is take 2. The first version was reverted for the 8.0.1 release.

Assisted-by: Stefan Eissing
Closes #10801
This commit is contained in:
Daniel Stenberg 2023-03-26 17:43:28 +02:00
parent 9d107b6954
commit 843b3baa3e
No known key found for this signature in database
GPG Key ID: 5CC908FDB71E12C2
6 changed files with 73 additions and 36 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
lib/ftp.c
View File

@ -3977,8 +3977,10 @@ static CURLcode wc_statemach(struct Curl_easy *data)
case CURLWC_DONE:
case CURLWC_ERROR:
case CURLWC_CLEAR:
if(wildcard->dtor)
if(wildcard->dtor) {
wildcard->dtor(wildcard->ftpwc);
wildcard->ftpwc = NULL;
}
return result;
}
}

89
lib/multi.c
View File

@ -392,12 +392,10 @@ static void sh_init(struct Curl_hash *hash, int hashsize)
* Called when a transfer is completed. Adds the given msg pointer to
* the list kept in the multi handle.
*/
static CURLMcode multi_addmsg(struct Curl_multi *multi,
struct Curl_message *msg)
static void multi_addmsg(struct Curl_multi *multi, struct Curl_message *msg)
{
Curl_llist_insert_next(&multi->msglist, multi->msglist.tail, msg,
&msg->list);
return CURLM_OK;
}
struct Curl_multi *Curl_multi_handle(int hashsize, /* socket hash */
@ -420,6 +418,7 @@ struct Curl_multi *Curl_multi_handle(int hashsize, /* socket hash */
Curl_llist_init(&multi->msglist, NULL);
Curl_llist_init(&multi->pending, NULL);
Curl_llist_init(&multi->msgsent, NULL);
multi->multiplexing = TRUE;
@ -465,6 +464,14 @@ struct Curl_multi *curl_multi_init(void)
CURL_DNS_HASH_SIZE);
}
/* returns TRUE if the easy handle is supposed to be present in the main link
list */
static bool in_main_list(struct Curl_easy *data)
{
return ((data->mstate != MSTATE_PENDING) &&
(data->mstate != MSTATE_MSGSENT));
}
static void link_easy(struct Curl_multi *multi,
struct Curl_easy *data)
{
@ -498,6 +505,8 @@ static void unlink_easy(struct Curl_multi *multi,
data->next->prev = data->prev;
else
multi->easylp = data->prev; /* point to last node */
data->prev = data->next = NULL;
}
@ -857,10 +866,16 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
called. Do it after multi_done() in case that sets another time! */
Curl_expire_clear(data);
if(data->connect_queue.ptr)
/* the handle was in the pending list waiting for an available connection,
so go ahead and remove it */
Curl_llist_remove(&multi->pending, &data->connect_queue, NULL);
if(data->connect_queue.ptr) {
/* the handle is in the pending or msgsent lists, so go ahead and remove
it */
if(data->mstate == MSTATE_PENDING)
Curl_llist_remove(&multi->pending, &data->connect_queue, NULL);
else
Curl_llist_remove(&multi->msgsent, &data->connect_queue, NULL);
}
if(in_main_list(data))
unlink_easy(multi, data);
if(data->dns.hostcachetype == HCACHE_MULTI) {
/* stop using the multi handle's DNS cache, *after* the possible
@ -921,7 +936,6 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
/* make sure there's no pending message in the queue sent from this easy
handle */
for(e = multi->msglist.head; e; e = e->next) {
struct Curl_message *msg = e->ptr;
@ -932,19 +946,6 @@ CURLMcode curl_multi_remove_handle(struct Curl_multi *multi,
}
}
/* Remove from the pending list if it is there. Otherwise this will
remain on the pending list forever due to the state change. */
for(e = multi->pending.head; e; e = e->next) {
struct Curl_easy *curr_data = e->ptr;
if(curr_data == data) {
Curl_llist_remove(&multi->pending, e, NULL);
break;
}
}
unlink_easy(multi, data);
/* NOTE NOTE NOTE
We do not touch the easy handle here! */
multi->num_easy--; /* one less to care about now */
@ -1952,11 +1953,6 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
}
break;
case MSTATE_PENDING:
/* We will stay here until there is a connection available. Then
we try again in the MSTATE_CONNECT state. */
break;
case MSTATE_CONNECT:
/* Connect. We want to get a connection identifier filled in. */
/* init this transfer. */
@ -1980,6 +1976,8 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
/* add this handle to the list of connect-pending handles */
Curl_llist_insert_next(&multi->pending, multi->pending.tail, data,
&data->connect_queue);
/* unlink from the main list */
unlink_easy(multi, data);
result = CURLE_OK;
break;
}
@ -2606,9 +2604,11 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
case MSTATE_COMPLETED:
break;
case MSTATE_PENDING:
case MSTATE_MSGSENT:
data->result = result;
return CURLM_OK; /* do nothing */
/* handles in these states should NOT be in this list */
DEBUGASSERT(0);
break;
default:
return CURLM_INTERNAL_ERROR;
@ -2696,10 +2696,17 @@ static CURLMcode multi_runsingle(struct Curl_multi *multi,
msg->extmsg.easy_handle = data;
msg->extmsg.data.result = result;
rc = multi_addmsg(multi, msg);
multi_addmsg(multi, msg);
DEBUGASSERT(!data->conn);
}
multistate(data, MSTATE_MSGSENT);
/* add this handle to the list of msgsent handles */
Curl_llist_insert_next(&multi->msgsent, multi->msgsent.tail, data,
&data->connect_queue);
/* unlink from the main list */
unlink_easy(multi, data);
return CURLM_OK;
}
} while((rc == CURLM_CALL_MULTI_PERFORM) || multi_ischanged(multi, FALSE));
@ -2730,6 +2737,9 @@ CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
/* Do the loop and only alter the signal ignore state if the next handle
has a different NO_SIGNAL state than the previous */
do {
/* the current node might be unlinked in multi_runsingle(), get the next
pointer now */
struct Curl_easy *datanext = data->next;
if(data->set.no_signal != nosig) {
sigpipe_restore(&pipe_st);
sigpipe_ignore(data, &pipe_st);
@ -2738,7 +2748,7 @@ CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
result = multi_runsingle(multi, &now, data);
if(result)
returncode = result;
data = data->next; /* operate on next handle */
data = datanext; /* operate on next handle */
} while(data);
sigpipe_restore(&pipe_st);
}
@ -2769,6 +2779,18 @@ CURLMcode curl_multi_perform(struct Curl_multi *multi, int *running_handles)
return returncode;
}
/* unlink_all_msgsent_handles() detaches all those easy handles from this
multi handle */
static void unlink_all_msgsent_handles(struct Curl_multi *multi)
{
struct Curl_llist_element *e = multi->msgsent.head;
if(e) {
struct Curl_easy *data = e->ptr;
DEBUGASSERT(data->mstate == MSTATE_MSGSENT);
data->multi = NULL;
}
}
CURLMcode curl_multi_cleanup(struct Curl_multi *multi)
{
struct Curl_easy *data;
@ -2780,6 +2802,8 @@ CURLMcode curl_multi_cleanup(struct Curl_multi *multi)
multi->magic = 0; /* not good anymore */
unlink_all_msgsent_handles(multi);
process_pending_handles(multi);
/* First remove all remaining easy handles */
data = multi->easyp;
while(data) {
@ -3711,6 +3735,8 @@ void Curl_multiuse_state(struct Curl_easy *data,
process_pending_handles(data->multi);
}
/* process_pending_handles() moves all handles from PENDING
back into the main list and change state to CONNECT */
static void process_pending_handles(struct Curl_multi *multi)
{
struct Curl_llist_element *e = multi->pending.head;
@ -3719,6 +3745,9 @@ static void process_pending_handles(struct Curl_multi *multi)
DEBUGASSERT(data->mstate == MSTATE_PENDING);
/* put it back into the main list */
link_easy(multi, data);
multistate(data, MSTATE_CONNECT);
/* Remove this node from the list */

2
lib/multihandle.h
View File

@ -101,6 +101,8 @@ struct Curl_multi {
struct Curl_llist pending; /* Curl_easys that are in the
MSTATE_PENDING state */
struct Curl_llist msgsent; /* Curl_easys that are in the
MSTATE_MSGSENT state */
/* callback function and user data pointer for the *socket() API */
curl_socket_callback socket_cb;

7
lib/transfer.c
View File

@ -1408,7 +1408,12 @@ CURLcode Curl_pretransfer(struct Curl_easy *data)
return CURLE_OUT_OF_MEMORY;
}
wc = data->wildcard;
if(wc->state < CURLWC_INIT) {
if((wc->state < CURLWC_INIT) ||
(wc->state >= CURLWC_CLEAN)) {
if(wc->ftpwc)
wc->dtor(wc->ftpwc);
Curl_safefree(wc->pattern);
Curl_safefree(wc->path);
result = Curl_wildcard_init(wc); /* init wildcard structures */
if(result)
return CURLE_OUT_OF_MEMORY;

4
lib/url.c
View File

@ -346,7 +346,6 @@ static void up_free(struct Curl_easy *data)
CURLcode Curl_close(struct Curl_easy **datap)
{
struct Curl_multi *m;
struct Curl_easy *data;
if(!datap || !*datap)
@ -360,8 +359,7 @@ CURLcode Curl_close(struct Curl_easy **datap)
/* Detach connection if any is left. This should not be normal, but can be
the case for example with CONNECT_ONLY + recv/send (test 556) */
Curl_detach_connection(data);
m = data->multi;
if(m)
if(data->multi)
/* This handle is still part of a multi handle, take care of this first
and detach this handle from there. */
curl_multi_remove_handle(data->multi, data);

3
lib/urldata.h
View File

@ -1903,7 +1903,8 @@ struct Curl_easy {
struct Curl_easy *prev;
struct connectdata *conn;
struct Curl_llist_element connect_queue;
struct Curl_llist_element connect_queue; /* for the pending and msgsent
lists */
struct Curl_llist_element conn_queue; /* list per connectdata */
CURLMstate mstate; /* the handle's state */