RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2025-01-12 00:39:32 +00:00
Code Issues Packages Projects Releases Wiki Activity
8895367fb1
haproxy/src/applet.c

91 lines
2.6 KiB
C
Raw Normal View History

MEDIUM: applet: add basic support for an applet run queue This will be needed so that we can schedule applets out of the streams. For now nothing calls the queue yet.
2015-04-13 15:11:11 +00:00
/*
* Functions managing applets
*
* Copyright 2000-2015 Willy Tarreau <w@1wt.eu>
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version
* 2 of the License, or (at your option) any later version.
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <common/config.h>
#include <common/mini-clist.h>
#include <proto/applet.h>
BUG/MAJOR: Fix how the list of entities waiting for a buffer is handled When an entity tries to get a buffer, if it cannot be allocted, for example because the number of buffers which may be allocated per process is limited, this entity is added in a list (called <buffer_wq>) and wait for an available buffer. Historically, the <buffer_wq> list was logically attached to streams because it were the only entities likely to be added in it. Now, applets can also be waiting for a free buffer. And with filters, we could imagine to have more other entities waiting for a buffer. So it make sense to have a generic list. Anyway, with the current design there is a bug. When an applet failed to get a buffer, it will wait. But we add the stream attached to the applet in <buffer_wq>, instead of the applet itself. So when a buffer is available, we wake up the stream and not the waiting applet. So, it is possible to have waiting applets and never awakened. So, now, <buffer_wq> is independant from streams. And we really add the waiting entity in <buffer_wq>. To be generic, the entity is responsible to define the callback used to awaken it. In addition, applets will still request an input buffer when they become active. But they will not be sleeped anymore if no buffer are available. So this is the responsibility to the applet I/O handler to check if this buffer is allocated or not. This way, an applet can decide if this buffer is required or not and can do additional processing if not. [wt: backport to 1.7 and 1.6]
2016-12-09 16:30:18 +00:00
#include <proto/channel.h>
MEDIUM: applet: implement a run queue for active appctx The new function is called for each round of polling in order to call any active appctx. For now we pick the stream interface from the appctx's owner. At the moment there's no appctx queued yet, but we have everything needed to queue them and remove them.
2015-04-19 07:59:31 +00:00
#include <proto/stream.h>
#include <proto/stream_interface.h>
MAJOR: applets: Use tasks, instead of rolling our own scheduler. There's no real reason to have a specific scheduler for applets anymore, so nuke it and just use tasks. This comes with some benefits, the first one being that applets cannot induce high latencies anymore since they share nice values with other tasks. Later it will be possible to configure the applets' nice value. The second benefit is that the applet scheduler was not very thread-friendly, having a big lock around it in prevision of this change. Thus applet-intensive workloads should now scale much better with threads. Some more improvement is possible now : some applets also use a task to handle timers and timeouts. These ones could now be simplified to use only one task.
2018-05-25 14:58:52 +00:00
#include <proto/task.h>
MEDIUM: applet: add basic support for an applet run queue This will be needed so that we can schedule applets out of the streams. For now nothing calls the queue yet.
2015-04-13 15:11:11 +00:00
MINOR: applet: Count number of (active) applets As for tasks, 2 counters has been added to track : * the total number of applets : nb_applets * the number of active applets : applets_active_queue [wt: needed for next fixes, to backport to 1.7 and 1.6]
2016-12-06 08:13:22 +00:00
unsigned int nb_applets = 0;
MAJOR: threads/applet: Handle multithreading for applets A global lock has been added to protect accesses to the list of active applets. A process mask has also been added on each applet. Like for FDs and tasks, it is used to know which threads are allowed to process an applet. Because applets are, most of time, linked to a session, it should be sticky on the same thread. But in all cases, it is the responsibility of the applet handler to lock what have to be protected in the applet context.
2017-06-19 10:38:55 +00:00
MEDIUM: appctx: check for allocation attempts in buffer allocation callbacks The buffer allocation callback appctx_res_wakeup() used to rely on old tricks to detect if a buffer was already granted to an appctx, namely by checking the task's state. Not only this test is not valid anymore, but it's inaccurate. Let's solely on SI_FL_WAIT_ROOM that is now set on allocation failure by the functions trying to allocate a buffer. The buffer is now allocated on the fly and the flag removed so that the consistency between the two remains granted. The patch also fixes minor issues such as the function being improperly declared inline(!) and the fact that using appctx_wakeup() sets the wakeup reason to TASK_WOKEN_OTHER while we try to use TASK_WOKEN_RES when waking up consecutive to a ressource allocation such as a buffer.
2018-11-06 16:32:37 +00:00
/* Callback used to wake up an applet when a buffer is available. The applet
* <appctx> is woken up if an input buffer was requested for the associated
* stream interface. In this case the buffer is immediately allocated and the
* function returns 1. Otherwise it returns 0. Note that this automatically
* covers multiple wake-up attempts by ensuring that the same buffer will not
* be accounted for multiple times.
*/
int appctx_buf_available(void *arg)
{
struct appctx *appctx = arg;
struct stream_interface *si = appctx->owner;
/* allocation requested ? */
MEDIUM: stream-int: use si_rx_buff_{rdy,blk} to report buffer readiness The stream interface used to conflate a missing buffer and lack of buffer space into SI_FL_WAIT_ROOM but this causes difficulties as these cannot be checked at the same moment and are not resolved at the same moment either. Now we instead mark the buffer as presumably available using si_rx_buff_rdy() and mark it as unavailable+requested using si_rx_buff_blk(). The call to si_alloc_buf() was moved after si_stop_put(). This makes sure that the SI_FL_RX_WAIT_EP flag is cleared on allocation failure so that the function is called again if the callee fails to do its work.
2018-11-14 14:12:08 +00:00
if (!(si->flags & SI_FL_RXBLK_BUFF))
return 0;
si_rx_buff_rdy(si);
/* was already allocated another way ? if so, don't take this one */
if (c_size(si_ic(si)) || si_ic(si)->pipe)
MEDIUM: appctx: check for allocation attempts in buffer allocation callbacks The buffer allocation callback appctx_res_wakeup() used to rely on old tricks to detect if a buffer was already granted to an appctx, namely by checking the task's state. Not only this test is not valid anymore, but it's inaccurate. Let's solely on SI_FL_WAIT_ROOM that is now set on allocation failure by the functions trying to allocate a buffer. The buffer is now allocated on the fly and the flag removed so that the consistency between the two remains granted. The patch also fixes minor issues such as the function being improperly declared inline(!) and the fact that using appctx_wakeup() sets the wakeup reason to TASK_WOKEN_OTHER while we try to use TASK_WOKEN_RES when waking up consecutive to a ressource allocation such as a buffer.
2018-11-06 16:32:37 +00:00
return 0;
/* allocation possible now ? */
MEDIUM: stream-int: use si_rx_buff_{rdy,blk} to report buffer readiness The stream interface used to conflate a missing buffer and lack of buffer space into SI_FL_WAIT_ROOM but this causes difficulties as these cannot be checked at the same moment and are not resolved at the same moment either. Now we instead mark the buffer as presumably available using si_rx_buff_rdy() and mark it as unavailable+requested using si_rx_buff_blk(). The call to si_alloc_buf() was moved after si_stop_put(). This makes sure that the SI_FL_RX_WAIT_EP flag is cleared on allocation failure so that the function is called again if the callee fails to do its work.
2018-11-14 14:12:08 +00:00
if (!b_alloc_margin(&si_ic(si)->buf, global.tune.reserved_bufs)) {
si_rx_buff_blk(si);
MEDIUM: appctx: check for allocation attempts in buffer allocation callbacks The buffer allocation callback appctx_res_wakeup() used to rely on old tricks to detect if a buffer was already granted to an appctx, namely by checking the task's state. Not only this test is not valid anymore, but it's inaccurate. Let's solely on SI_FL_WAIT_ROOM that is now set on allocation failure by the functions trying to allocate a buffer. The buffer is now allocated on the fly and the flag removed so that the consistency between the two remains granted. The patch also fixes minor issues such as the function being improperly declared inline(!) and the fact that using appctx_wakeup() sets the wakeup reason to TASK_WOKEN_OTHER while we try to use TASK_WOKEN_RES when waking up consecutive to a ressource allocation such as a buffer.
2018-11-06 16:32:37 +00:00
return 0;
MEDIUM: stream-int: use si_rx_buff_{rdy,blk} to report buffer readiness The stream interface used to conflate a missing buffer and lack of buffer space into SI_FL_WAIT_ROOM but this causes difficulties as these cannot be checked at the same moment and are not resolved at the same moment either. Now we instead mark the buffer as presumably available using si_rx_buff_rdy() and mark it as unavailable+requested using si_rx_buff_blk(). The call to si_alloc_buf() was moved after si_stop_put(). This makes sure that the SI_FL_RX_WAIT_EP flag is cleared on allocation failure so that the function is called again if the callee fails to do its work.
2018-11-14 14:12:08 +00:00
}
MEDIUM: appctx: check for allocation attempts in buffer allocation callbacks The buffer allocation callback appctx_res_wakeup() used to rely on old tricks to detect if a buffer was already granted to an appctx, namely by checking the task's state. Not only this test is not valid anymore, but it's inaccurate. Let's solely on SI_FL_WAIT_ROOM that is now set on allocation failure by the functions trying to allocate a buffer. The buffer is now allocated on the fly and the flag removed so that the consistency between the two remains granted. The patch also fixes minor issues such as the function being improperly declared inline(!) and the fact that using appctx_wakeup() sets the wakeup reason to TASK_WOKEN_OTHER while we try to use TASK_WOKEN_RES when waking up consecutive to a ressource allocation such as a buffer.
2018-11-06 16:32:37 +00:00
task_wakeup(appctx->t, TASK_WOKEN_RES);
return 1;
}
/* Default applet handler */
MAJOR: applets: Use tasks, instead of rolling our own scheduler. There's no real reason to have a specific scheduler for applets anymore, so nuke it and just use tasks. This comes with some benefits, the first one being that applets cannot induce high latencies anymore since they share nice values with other tasks. Later it will be possible to configure the applets' nice value. The second benefit is that the applet scheduler was not very thread-friendly, having a big lock around it in prevision of this change. Thus applet-intensive workloads should now scale much better with threads. Some more improvement is possible now : some applets also use a task to handle timers and timeouts. These ones could now be simplified to use only one task.
2018-05-25 14:58:52 +00:00
struct task *task_run_applet(struct task *t, void *context, unsigned short state)
MEDIUM: applet: implement a run queue for active appctx The new function is called for each round of polling in order to call any active appctx. For now we pick the stream interface from the appctx's owner. At the moment there's no appctx queued yet, but we have everything needed to queue them and remove them.
2015-04-19 07:59:31 +00:00
{
MAJOR: applets: Use tasks, instead of rolling our own scheduler. There's no real reason to have a specific scheduler for applets anymore, so nuke it and just use tasks. This comes with some benefits, the first one being that applets cannot induce high latencies anymore since they share nice values with other tasks. Later it will be possible to configure the applets' nice value. The second benefit is that the applet scheduler was not very thread-friendly, having a big lock around it in prevision of this change. Thus applet-intensive workloads should now scale much better with threads. Some more improvement is possible now : some applets also use a task to handle timers and timeouts. These ones could now be simplified to use only one task.
2018-05-25 14:58:52 +00:00
struct appctx *app = context;
struct stream_interface *si = app->owner;
MEDIUM: applet: implement a run queue for active appctx The new function is called for each round of polling in order to call any active appctx. For now we pick the stream interface from the appctx's owner. At the moment there's no appctx queued yet, but we have everything needed to queue them and remove them.
2015-04-19 07:59:31 +00:00
MAJOR: applets: Use tasks, instead of rolling our own scheduler. There's no real reason to have a specific scheduler for applets anymore, so nuke it and just use tasks. This comes with some benefits, the first one being that applets cannot induce high latencies anymore since they share nice values with other tasks. Later it will be possible to configure the applets' nice value. The second benefit is that the applet scheduler was not very thread-friendly, having a big lock around it in prevision of this change. Thus applet-intensive workloads should now scale much better with threads. Some more improvement is possible now : some applets also use a task to handle timers and timeouts. These ones could now be simplified to use only one task.
2018-05-25 14:58:52 +00:00
if (app->state & APPLET_WANT_DIE) {
__appctx_free(app);
return NULL;
MAJOR: applet: applet scheduler rework. In order to authorize call of appctx_wakeup on running task: - from within the task handler itself. - in futur, from another thread. The appctx is considered paused as default after running the handler. The handler should explicitly call appctx_wakeup to be re-called. When the appctx_free is called on a running handler. The real free is postponed at the end of the handler process.
2017-06-26 14:36:53 +00:00
}
MAJOR: applets: Use tasks, instead of rolling our own scheduler. There's no real reason to have a specific scheduler for applets anymore, so nuke it and just use tasks. This comes with some benefits, the first one being that applets cannot induce high latencies anymore since they share nice values with other tasks. Later it will be possible to configure the applets' nice value. The second benefit is that the applet scheduler was not very thread-friendly, having a big lock around it in prevision of this change. Thus applet-intensive workloads should now scale much better with threads. Some more improvement is possible now : some applets also use a task to handle timers and timeouts. These ones could now be simplified to use only one task.
2018-05-25 14:58:52 +00:00
/* We always pretend the applet can't get and doesn't want to
* put, it's up to it to change this if needed. This ensures
* that one applet which ignores any event will not spin.
BUG/MAJOR: applet: use a separate run queue to maintain list integrity If an applet wakes up and causes the next one to sleep, the active list is corrupted and cannot be scanned anymore, as the process then loops over the next element. In order to avoid this problem, we move the active applet list to a run queue and reinit the active list. Only the first element of this queue is checked, and if the element is not removed, it is removed and requeued into the active list. Since we're using a distinct list, if an applet wants to requeue another applet into the active list, it properly gets added to the active list and not to the run queue. This stops the infinite loop issue that could be caused with Lua applets, and in any future configuration where two applets could be attached together.
2015-09-25 15:56:16 +00:00
*/
MINOR: stream-int: rename si_applet_{want|stop|cant}_{get|put} It doesn't make sense to limit this code to applets, as any stream interface can use it. Let's rename it by simply dropping the "applet_" part of the name. No other change was made except updating the comments.
2018-11-06 17:46:37 +00:00
si_cant_get(si);
MINOR: stream-int: replace si_{want,stop}_put() with si_rx_endp_{more,done}() Here it's only a 1-to-1 replacement.
2018-11-14 16:54:13 +00:00
si_rx_endp_done(si);
MEDIUM: applet: implement a run queue for active appctx The new function is called for each round of polling in order to call any active appctx. For now we pick the stream interface from the appctx's owner. At the moment there's no appctx queued yet, but we have everything needed to queue them and remove them.
2015-04-19 07:59:31 +00:00
MEDIUM: stream-int: use si_rx_buff_{rdy,blk} to report buffer readiness The stream interface used to conflate a missing buffer and lack of buffer space into SI_FL_WAIT_ROOM but this causes difficulties as these cannot be checked at the same moment and are not resolved at the same moment either. Now we instead mark the buffer as presumably available using si_rx_buff_rdy() and mark it as unavailable+requested using si_rx_buff_blk(). The call to si_alloc_buf() was moved after si_stop_put(). This makes sure that the SI_FL_RX_WAIT_EP flag is cleared on allocation failure so that the function is called again if the callee fails to do its work.
2018-11-14 14:12:08 +00:00
/* Now we'll try to allocate the input buffer. We wake up the applet in
* all cases. So this is the applet's responsibility to check if this
* buffer was allocated or not. This leaves a chance for applets to do
* some other processing if needed. The applet doesn't have anything to
* do if it needs the buffer, it will be called again upon readiness.
*/
if (!si_alloc_ibuf(si, &app->buffer_wait))
MINOR: stream-int: replace si_{want,stop}_put() with si_rx_endp_{more,done}() Here it's only a 1-to-1 replacement.
2018-11-14 16:54:13 +00:00
si_rx_endp_more(si);
MEDIUM: stream-int: use si_rx_buff_{rdy,blk} to report buffer readiness The stream interface used to conflate a missing buffer and lack of buffer space into SI_FL_WAIT_ROOM but this causes difficulties as these cannot be checked at the same moment and are not resolved at the same moment either. Now we instead mark the buffer as presumably available using si_rx_buff_rdy() and mark it as unavailable+requested using si_rx_buff_blk(). The call to si_alloc_buf() was moved after si_stop_put(). This makes sure that the SI_FL_RX_WAIT_EP flag is cleared on allocation failure so that the function is called again if the callee fails to do its work.
2018-11-14 14:12:08 +00:00
MAJOR: applets: Use tasks, instead of rolling our own scheduler. There's no real reason to have a specific scheduler for applets anymore, so nuke it and just use tasks. This comes with some benefits, the first one being that applets cannot induce high latencies anymore since they share nice values with other tasks. Later it will be possible to configure the applets' nice value. The second benefit is that the applet scheduler was not very thread-friendly, having a big lock around it in prevision of this change. Thus applet-intensive workloads should now scale much better with threads. Some more improvement is possible now : some applets also use a task to handle timers and timeouts. These ones could now be simplified to use only one task.
2018-05-25 14:58:52 +00:00
app->applet->fct(app);
si_applet_wake_cb(si);
channel_release_buffer(si_ic(si), &app->buffer_wait);
return t;
MEDIUM: applet: implement a run queue for active appctx The new function is called for each round of polling in order to call any active appctx. For now we pick the stream interface from the appctx's owner. At the moment there's no appctx queued yet, but we have everything needed to queue them and remove them.
2015-04-19 07:59:31 +00:00
}
MAJOR: threads/applet: Handle multithreading for applets A global lock has been added to protect accesses to the list of active applets. A process mask has also been added on each applet. Like for FDs and tasks, it is used to know which threads are allowed to process an applet. Because applets are, most of time, linked to a session, it should be sticky on the same thread. But in all cases, it is the responsibility of the applet handler to lock what have to be protected in the applet context.
2017-06-19 10:38:55 +00:00
Reference in New Issue Copy Permalink