lkml.org 
[lkml]   [2008]   [Oct]   [15]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [PATCH] fastboot: Introduce an asynchronous function call mechanism
> On Sun, 12 Oct 2008 19:44:27 -0400 Arjan van de Ven <arjan@infradead.org> wrote:
> after the discussion on fastboot I came up with the following patch
> (this was all done at 35000 feet so if it's h0rked .. I'll claim lack of oxygen)
>
> I'll also reply to this email with 2 users of the new infrastructure just to show how it'd be used.
>
>
>
> >From c5fd398d7210bcdc726dc813523d8b4c58481553 Mon Sep 17 00:00:00 2001
> From: Arjan van de Ven <arjan@linux.intel.com>
> Date: Sun, 12 Oct 2008 15:27:22 -0400
> Subject: [PATCH] fastboot: Introduce an asynchronous function call mechanism
>
> During the system boot there are many things that take a long time
> and also can be done asynchronous; this patch introduces a call_async()
> function that implements a pool of threads to execute the asynchronous
> calls.
>
> The calls are divided into pools, and within a pool the calls are processed
> in order; this is done to preserve stable device numbers.
>
> ...
>
> +#include <linux/list.h>
> +#include <linux/workqueue.h>
> +#include <linux/wait.h>
> +#include <linux/hrtimer.h>
> +#include <linux/slab.h>
> +#include <linux/kthread.h>
> +#include <linux/module.h>
> +#include <linux/spinlock.h>
> +
> +#include <stdarg.h>
> +
> +static int async_active = 0;

?

> +typedef int (*async_func_t_0)(void);
> +typedef int (*async_func_t_1)(void *);
> +typedef int (*async_func_t_2)(void *, void *);
> +typedef int (*async_func_t_3)(void *, void *, void *);
> +typedef int (*async_func_t_4)(void *, void *, void *, void *);
> +
> +
> +struct async_item {
> + struct list_head list;
> +
> + async_func_t_0 func;
> + int argument_count;
> + void *arg1;
> + void *arg2;
> + void *arg3;
> + void *arg4;
> +};
> +
> +
> +static struct list_head list_pool[ASYNC_MAX_POOL + 1];
> +static struct task_struct * thread_pool[ASYNC_MAX_POOL + 1];
> +static wait_queue_head_t waitqueue_pool[ASYNC_MAX_POOL + 1];
> +static int pool_count[ASYNC_MAX_POOL + 1];
> +
> +static spinlock_t pool_lock;

DEFINE_SPINLOCK(), remove spin_lock_init()

> +extern int initcall_debug;

no externs in C.

> +static void do_async_item(struct async_item *item)
> +{
> + ktime_t t0, t1, delta;
> + int result;
> + async_func_t_0 fn0 = item->func;
> + async_func_t_1 fn1 = (async_func_t_1)item->func;
> + async_func_t_2 fn2 = (async_func_t_2)item->func;
> + async_func_t_3 fn3 = (async_func_t_3)item->func;
> + async_func_t_4 fn4 = (async_func_t_4)item->func;
> +
> + if (initcall_debug) {
> + printk("calling %pF @ %i\n", item->func,
> + task_pid_nr(current));
> + t0 = ktime_get();
> + }
> +
> + switch (item->argument_count) {
> + case 0:
> + result = fn0();
> + break;
> + case 1:
> + result = fn1(item->arg1);
> + break;
> + case 2:
> + result = fn2(item->arg1, item->arg2);
> + break;
> + case 3:
> + result = fn3(item->arg1, item->arg2, item->arg3);
> + break;
> + case 4:
> + result = fn4(item->arg1, item->arg2, item->arg3, item->arg4);
> + break;
> + default:
> + result = 0;
> + WARN_ON(1);
> + }
> + if (initcall_debug) {
> + t1 = ktime_get();
> + delta = ktime_sub(t1, t0);
> +
> + printk("asynccall %pF returned %d after %Ld msecs\n",
> + item->func, result,
> + (unsigned long long) delta.tv64 >> 20);
> + }
> +}
> +
> +
> +static int async_thread(void *data)
> +{
> + int pool = (unsigned long) data;
> +
> + DECLARE_WAITQUEUE(wq, current);

random newline in locals

> + add_wait_queue(&waitqueue_pool[pool], &wq);

never gets removed

> + while (!kthread_should_stop()) {
> + struct async_item *item = NULL;
> +
> + spin_lock(&pool_lock);
> + set_current_state(TASK_INTERRUPTIBLE);
> + if (!list_empty(&list_pool[pool])) {
> + item = list_first_entry(&list_pool[pool], struct async_item, list);
> + list_del(&item->list);
> + pool_count[pool]--;
> + }
> + spin_unlock(&pool_lock);
> +
> + if (!item) {
> + schedule();
> + continue;
> + }
> + __set_current_state(TASK_RUNNING);
> + do_async_item(item);
> + kfree(item);
> + wake_up(&waitqueue_pool[pool]);
> + }
> + return 0;
> +}
> +
> +
> +void init_async_calls(void)
> +{
> + unsigned long i;
> + spin_lock_init(&pool_lock);
> + for (i = 0; i <= ASYNC_MAX_POOL; i++) {
> + INIT_LIST_HEAD(&list_pool[i]);
> + init_waitqueue_head(&waitqueue_pool[i]);
> + thread_pool[i] = kthread_run(&async_thread, (void *)i, "kasyncd/%li", i);
> + }
> + async_active = 1;
> +}

Please talk to Evgeniy about his new thread_pool stuff which I've suggested
become a generic library.

(looks at changelog, doesn't really understand the need for the thread pool
thing, doesn't understand the comment about device numbers)

> +
> +void call_async(int pool_number, int argc, ...)

This looks like schedule_work(). Why cannot that be used (perhaps after
suitable modification)?





\
 
 \ /
  Last update: 2008-10-15 10:45    [from the cache]
©2003-2011 Jasper Spaans