Партнёры:
Хостинг:
taskqueue - asynchronous task execution
typedef void (*task_fn_t)(void *context, int pending);
typedef void (*taskqueue_enqueue_fn)(void *context);
struct task {
STAILQ_ENTRY(task) ta_link; /* link for queue */
u_short ta_pending; /* count times queued */
u_short ta_priority; /* priority of task in queue */
task_fn_t ta_func; /* task handler */
void *ta_context; /* argument for handler */
};
struct taskqueue *
taskqueue_create (const char *name int mflags taskqueue_enqueue_fn enqueue void *context struct proc **);
The function
taskqueue_create ();
is used to create new queues.
The arguments to
taskqueue_create ();
include a name that should be unique,
a set of
malloc(9)
flags that specify whether the call to
malloc ();
is allowed to sleep,
a function that is called from
taskqueue_enqueue ();
when a task is added to the queue,
and a pointer to the memory location where the identity of the
thread that services the queue is recorded.
The function called from
taskqueue_enqueue ();
must arrange for the queue to be processed
(for instance by scheduling a software interrupt or waking a kernel
thread).
The memory location where the thread identity is recorded is used
to signal the service thread(s) to terminate--when this value is set to
zero and the thread is signaled it will terminate.
The function
taskqueue_free ();
should be used to remove the queue from the global list of queues
and free the memory used by the queue.
Any tasks that are on the queue will be executed at this time after
which the thread servicing the queue will be signaled that it should exit.
The system maintains a list of all queues which can be searched using
taskqueue_find (.);
The first queue whose name matches is returned, otherwise
NULL
To add a task to the list of tasks queued on a taskqueue, call
taskqueue_enqueue ();
with pointers to the queue and task.
If the task's
ta_pending
field is non-zero,
then it is simply incremented to reflect the number of times the task
was enqueued.
Otherwise,
the task is added to the list before the first task which has a lower
ta_priority
value or at the end of the list if no tasks have a lower priority.
Enqueueing a task does not perform any memory allocation which makes
it suitable for calling from an interrupt handler.
This function will return
Er EPIPE
if the queue is being freed.
The function
taskqueue_enqueue_fast ();
should be used in place of
taskqueue_enqueue ();
when the enqueuing must happen from a fast interrupt handler.
This method uses spin locks to avoid the possibility of sleeping in the fast
interrupt context.
To execute all the tasks on a queue,
call
taskqueue_run ();
or
taskqueue_run_fast ();
depending on the flavour of the queue.
When a task is executed,
first it is removed from the queue,
the value of
ta_pending
is recorded and then the field is zeroed.
The function
ta_func
from the task structure is called with the value of the field
ta_context
as its first argument
and the value of
ta_pending
as its second argument.
After the function
ta_func
returns,
wakeup(9)
is called on the task pointer passed to
taskqueue_enqueue (.);
The
taskqueue_drain ();
function is used to wait for the task to finish.
There is no guarantee that the task will not be
enqueued after call to
taskqueue_drain (.);
A convenience macro,
TASK_INIT (task priority func context);
is provided to initialise a
task
structure.
The values of
priority
func
and
context
are simply copied into the task structure fields and the
ta_pending
field is cleared.
Three macros
TASKQUEUE_DECLARE (name ,);
TASKQUEUE_DEFINE (name enqueue context init ,);
and
TASKQUEUE_DEFINE_THREAD (name);
are used to declare a reference to a global queue, to define the
implementation of the queue, and declare a queue that uses its own thread.
The
TASKQUEUE_DEFINE ();
macro arranges to call
taskqueue_create ();
with the values of its
name
enqueue
and
context
arguments during system initialisation.
After calling
taskqueue_create (,);
the
init
argument to the macro is executed as a C statement,
allowing any further initialisation to be performed
(such as registering an interrupt handler etc.)
The
TASKQUEUE_DEFINE_THREAD ();
macro defines a new taskqueue with its own kernel thread to serve tasks.
The variable
Vt struct proc *taskqueue_name_proc
is defined which contains the kernel thread serving the tasks.
The variable
Vt struct taskqueue *taskqueue_name
is used to enqueue tasks onto the queue.
To use these queues,
call
taskqueue_enqueue ();
with the value of the global taskqueue variable for the queue you wish to
use
( taskqueue_swi
taskqueue_swi_giant
or
taskqueue_thread )
Use
taskqueue_enqueue_fast ();
for the global taskqueue variable
taskqueue_fast
The software interrupt queues can be used, for instance, for implementing interrupt handlers which must perform a significant amount of processing in the handler. The hardware interrupt handler would perform minimal processing of the interrupt and then enqueue a task to finish the work. This reduces to a minimum the amount of time spent with interrupts disabled.
The thread queue can be used, for instance, by interrupt level routines that need to call kernel functions that do things that can only be done from a thread context. (e.g., call malloc with the M_WAITOK flag.)
Note that tasks queued on shared taskqueues such as taskqueue_swi may be delayed an indeterminate amount of time before execution. If queueing delays cannot be tolerated then a private taskqueue should be created with a dedicated processing thread.
|
Закладки на сайте Проследить за страницей |
Created 1996-2024 by Maxim Chirkov Добавить, Поддержать, Вебмастеру |