Syslets, "Threadlets", generic AIO support, v3
Subsystems (6)
cover Syslets, "Threadlets", generic AIO support, v3
this is the v3 release of the syslet/threadlet subsystem:
http://redhat.com/~mingo/syslet-patches/
This release came a few days later than i originally wanted, because i've implemented many fundamental changes to the code. The biggest highlights of v3 are:
- "Threadlets": the introduction of the 'threadlet' execution concept.
- syslets: multiple rings support with no kernel-side footprint, the elimination of mlock() pinning, no async_register/unregister() calls needed anymore and more.
"Threadlets" are basically the user-space equivalent of syslets: small functions of execution that the kernel attempts to execute without scheduling. If the threadlet blocks, the kernel creates a real thread from it, and execution continues in that thread. The 'head' context (the context that never blocks) returns to the original function that called the threadlet. Threadlets are very easy to use:
long my_threadlet_fn(void *data)
{
char *name = data;
int fd;
fd = open(name, O_RDONLY);
if (fd < 0)
goto out;
fstat(fd, &stat);
read(fd, buf, count)
...out:
return threadlet_complete(); }
main()
{
done = threadlet_exec(threadlet_fn, new_stack, &user_head);
if (!done)
reqs_queued++;
}There is no limitation whatsoever about how a threadlet function can look like: it can use arbitrary system-calls and all execution will be procedural. There is no 'registration' needed when running threadlets
either: the kernel will take care of all the details, user-space just runs a threadlet without any preparation and that's it.
Completion of async threadlets can be done from user-space via any of the existing APIs: in threadlet-test.c (see the async-test-v3.tar.gz user-space examples at the URL above) i've for example used a futex between the head and the async threads to do threadlet notification. But select(), poll() or signals can be used too - whichever is most convenient to the application writer.
Threadlets can also be thought of as 'optional threads': they execute in the original context as long as they do not block, but once they block, they are moved off into their separate thread context - and the original context can continue execution.
Threadlets can also be thought of as 'on-demand parallelism': user-space does not have to worry about setting up, sizing and feeding a thread pool - the kernel will execute the workload in a single-threaded manner as long as it makes sense, but once the context blocks, a parallel context is created. So parallelism inside applications is utilized in a natural way. (The best place to do this is in the kernel - user-space has no idea about what level of parallelism is best for any given moment.)
I believe this threadlet concept is what user-space will want to use for programmable parallelism.
[ Note that right now there's a pair of system-calls: sys_threadlet_on()
and sys_threadlet_off() that demarks the beginning and the end of a syslet function, which enter the kernel even in the 'cached' case - but my plan is to do these two system calls via a vsyscall, without having to enter the kernel at all. That will reduce cached threadlet execution NULL-overhead to around 10 nsecs - making it essentially zero. ]
Threadlets share much of the scheduling infrastructure with syslets.
Syslets (small, kernel-side, scripted "syscall plugins") are still supported - they are (much...) harder to program than threadlets but they allow the highest performance. Core infrastructure libraries like glibc/libaio are expected to use syslets. Jens Axboe's FIO tool already includes support for v2 syslets, and the following patch updates FIO to the v3 API:
http://redhat.com/~mingo/syslet-patches/fio-syslet-v3.patch
Furthermore, the syslet code and API has been significantly enhanced as well:
- support for multiple completion rings has been added
- there is no more mlock()ing of the completion ring(s)
- sys_async_register()/unregister() has been removed as it is not needed anymore. sys_async_exec() can be called straight away.
- there is no kernel-side resource used up by async completion rings at all (all the state is in user-space), so an arbitrary number of completion rings are supported.
plus lots of bugs were fixed and a good number of cleanups were done as well. The v3 code is ABI-incompatible with v2, due to these fundamental changes.
As always, comments, suggestions, reports are welcome.
Ingo
PATCH 1/13 syslets: add async.h include file, kernel-side API definitions
From: Ingo Molnar <[email protected]>
add include/linux/async.h which contains the kernel-side API declarations.
it also provides NOP stubs for the !CONFIG_ASYNC_SUPPORT case.
--- include/linux/async.h | 92 ++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 92 insertions(+)
include/linux/async.h new file +92 -0
@@ -0,0 +1,92 @@ +#ifndef _LINUX_ASYNC_H +#define _LINUX_ASYNC_H + +#include <linux/completion.h> +#include <linux/compiler.h> + +/* +* The syslet subsystem - asynchronous syscall execution support. +* +* Generic kernel API definitions: +*/ + +struct syslet_uatom ; +struct async_thread ; +struct async_head ; + +/* +* The syslet subsystem - asynchronous syscall execution support. +* +* Syslet-subsystem internal definitions: +*/ + +/* +* The kernel-side copy of a syslet atom - with arguments expanded: +*/ +struct syslet_atom { +unsigned long flags; +unsigned long nr; +long __user *ret_ptr; +struct syslet_uatom __user *next; +unsigned long args[6 ]; +}; + +/* +* The 'async head' is the thread which has user-space context (ptregs) +* 'below it' - this is the one that can return to user-space: +*/ +struct async_head { +spinlock_t lock; +struct task_struct *user_task; + +struct list_head ready_async_threads; +struct list_head busy_async_threads; + +struct mutex completion_lock; +long events_left; +wait_queue_head_t wait; + +struct async_head_user __user *ahu; + +unsigned long __user *new_stackp; +unsigned long new_eip; +unsigned long restore_stack; +unsigned long restore_eip; +struct completion start_done; +struct completion exit_done; +}; + +/* +* The 'async thread' is either a newly created async thread or it is +* an 'ex-head' - it cannot return to user-space and only has kernel +* context. +*/ +struct async_thread { +struct task_struct *task; +struct syslet_uatom __user *work; +unsigned long user_stack; +unsigned long user_eip; +struct async_head *ah; + +struct list_head entry; + +unsigned int exit; +}; + +#ifdef CONFIG_ASYNC_SUPPORT +extern void async_init (struct task_struct *t); +extern void async_exit (struct task_struct *t); +extern void __async_schedule (struct task_struct *t); +#else /* !CONFIG_ASYNC_SUPPORT */ +static inline void async_init (struct task_struct *t) +{ +} +static inline void async_exit (struct task_struct *t) +{ +} +static inline void __async_schedule (struct task_struct *t) +{ +} +#endif /* !CONFIG_ASYNC_SUPPORT */ + +#endif
PATCH 2/13 syslets: add syslet.h include file, user API/ABI definitions
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
add include/linux/syslet.h which contains the user-space API/ABI declarations. Add the new header to include/linux/Kbuild as well.
--- include/linux/Kbuild | 1 include/linux/syslet.h | 155 +++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 156 insertions(+)
include/linux/Kbuild +1 -0
@@ -140,6 +140,7 @@ header-y += sockios.h header-y += som.h header-y += sound.h header-y += synclink.h +header-y += syslet.h header-y += telephony.h header-y += termios.h header-y += ticable.h
include/linux/syslet.h new file +155 -0
155 lines not on this page · raw message
PATCH 3/13 syslets: generic kernel bits
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
add the kernel generic bits - these are present even if !CONFIG_ASYNC_SUPPORT.
--- fs/exec.c | 4 ++++ include/linux/sched.h | 23 ++++++++++++++++++++++- kernel/capability.c | 3 +++ kernel/exit.c | 7 +++++++ kernel/fork.c | 5 +++++ kernel/sched.c | 9 +++++++++ kernel/sys.c | 36 ++++++++++++++++++++++++++++++++++++ 7 files changed, 86 insertions(+), 1 deletion(-)
fs/exec.c +4 -0
@@ -1446,6 +1446,10 @@ static int coredump_wait(int exit_code) tsk->vfork_done =NULL ;complete (vfork_done); } +/* +* Make sure we exit our async context before waiting: +*/ +async_exit (tsk);if (core_waiters)wait_for_completion (&startup_done);
include/linux/sched.h +22 -1
@@ -83,12 +83,12 @@ struct sched_param {#include <linux/timer.h> #include <linux/hrtimer.h> #include <linux/task_io_accounting.h> +#include <linux/async.h> #include <asm/processor.h> struct exec_domain ;struct futex_pi_state ; -/* * List of flags we want to share for kernel threads, * if only because they are not used by them anyway.
@@ -997,6 +997,12 @@ struct task_struct {/* journalling filesystem info */ void *journal_info; +/* async syscall support: */ +struct async_thread *at, *async_ready; +struct async_head *ah; +struct async_thread __at; +struct async_head __ah; +/* VM state */ struct reclaim_state *reclaim_state;
@@ -1053,6 +1059,21 @@ struct task_struct {#endif }; +/* +* Is an async syscall being executed currently? +*/ +#ifdef CONFIG_ASYNC_SUPPORT +static inline int async_syscall (struct task_struct *t) +{ +return t->async_ready !=NULL ; +} +#else /* !CONFIG_ASYNC_SUPPORT */ +static inline int async_syscall (struct task_struct *t) +{ +return 0 ; +} +#endif /* !CONFIG_ASYNC_SUPPORT */ +static inline pid_t process_group (struct task_struct *tsk) {return tsk->signal->pgrp;
kernel/capability.c +3 -0
@@ -176,6 +176,9 @@ asmlinkage long sys_capset(cap_user_headint ret;pid_t pid; +if (async_syscall (current)) +return -ENOSYS ; +if (get_user (version, &header->version))return -EFAULT ;
kernel/exit.c +7 -0
@@ -26,6 +26,7 @@#include <linux/ptrace.h> #include <linux/profile.h> #include <linux/mount.h> +#include <linux/async.h> #include <linux/proc_fs.h> #include <linux/mempolicy.h> #include <linux/taskstats_kern.h>
@@ -889,6 +890,12 @@ fastcall NORET_TYPE void do_exit(long coschedule (); } +/* +* Note: async threads have to exit their context before the MM +* exit (due to the coredumping wait): +*/ +async_exit (tsk); + tsk->flags |=PF_EXITING ;if (unlikely (in_atomic ()))
kernel/fork.c +5 -0
@@ -22,6 +22,7 @@#include <linux/personality.h> #include <linux/mempolicy.h> #include <linux/sem.h> +#include <linux/async.h> #include <linux/file.h> #include <linux/key.h> #include <linux/binfmts.h>
@@ -1054,6 +1055,7 @@ static struct task_struct *copy_process( p->lock_depth =-1 ;/* -1 = no lock */ do_posix_clock_monotonic_gettime (&p->start_time); +async_init (p); p->security =NULL ; p->io_context =NULL ; p->io_wait =NULL ;
@@ -1621,6 +1623,9 @@ asmlinkage long sys_unshare(unsigned lonstruct uts_namespace *uts, *new_uts =NULL ;struct ipc_namespace *ipc, *new_ipc =NULL ; +if (async_syscall (current)) +return -ENOSYS ; +check_unshare_flags (&unshare_flags);/* Return -EINVAL for all unsupported flags */
kernel/sched.c +9 -0
@@ -38,6 +38,7 @@#include <linux/vmalloc.h> #include <linux/blkdev.h> #include <linux/delay.h> +#include <linux/async.h> #include <linux/smp.h> #include <linux/threads.h> #include <linux/timer.h>
@@ -3436,6 +3437,14 @@ asmlinkage void __sched schedule(void) }profile_hit (SCHED_PROFILING ,__builtin_return_address (0 )); + prev = current; +if (unlikely (prev->async_ready)) { +if (prev->state && !(preempt_count () &PREEMPT_ACTIVE ) && + (!(prev->state &TASK_INTERRUPTIBLE ) || + !signal_pending (prev))) +__async_schedule (prev); + } + need_resched:preempt_disable (); prev = current;
kernel/sys.c +36 -0
@@ -933,6 +933,9 @@ asmlinkage long sys_setregid(gid_t rgid,int new_egid = old_egid;int retval; +if (async_syscall (current)) +return -ENOSYS ; + retval =security_task_setgid (rgid, egid, (gid_t)-1 ,LSM_SETID_RE );if (retval)return retval;
@@ -979,6 +982,9 @@ asmlinkage long sys_setgid(gid_t gid)int old_egid = current->egid;int retval; +if (async_syscall (current)) +return -ENOSYS ; + retval =security_task_setgid (gid, (gid_t)-1 , (gid_t)-1 ,LSM_SETID_ID );if (retval)return retval;
@@ -1049,6 +1055,9 @@ asmlinkage long sys_setreuid(uid_t ruid,int old_ruid, old_euid, old_suid, new_ruid, new_euid;int retval; +if (async_syscall (current)) +return -ENOSYS ; + retval =security_task_setuid (ruid, euid, (uid_t)-1 ,LSM_SETID_RE );if (retval)return retval;
@@ -1112,6 +1121,9 @@ asmlinkage long sys_setuid(uid_t uid)int old_ruid, old_suid, new_suid;int retval; +if (async_syscall (current)) +return -ENOSYS ; + retval =security_task_setuid (uid, (uid_t)-1 , (uid_t)-1 ,LSM_SETID_ID );if (retval)return retval;
@@ -1152,6 +1164,9 @@ asmlinkage long sys_setresuid(uid_t ruidint old_suid = current->suid;int retval; +if (async_syscall (current)) +return -ENOSYS ; + retval =security_task_setuid (ruid, euid, suid,LSM_SETID_RES );if (retval)return retval;
@@ -1206,6 +1221,9 @@ asmlinkage long sys_setresgid(gid_t rgid {int retval; +if (async_syscall (current)) +return -ENOSYS ; + retval =security_task_setgid (rgid, egid, sgid,LSM_SETID_RES );if (retval)return retval;
@@ -1261,6 +1279,9 @@ asmlinkage long sys_setfsuid(uid_t uid) {int old_fsuid; +if (async_syscall (current)) +return -ENOSYS ; + old_fsuid = current->fsuid;if (security_task_setuid (uid, (uid_t)-1 , (uid_t)-1 ,LSM_SETID_FS ))return old_fsuid;
@@ -1290,6 +1311,9 @@ asmlinkage long sys_setfsgid(gid_t gid) {int old_fsgid; +if (async_syscall (current)) +return -ENOSYS ; + old_fsgid = current->fsgid;if (security_task_setgid (gid, (gid_t)-1 , (gid_t)-1 ,LSM_SETID_FS ))return old_fsgid;
@@ -1365,6 +1389,9 @@ asmlinkage long sys_setpgid(pid_t pid, pstruct task_struct *group_leader = current->group_leader;int err = -EINVAL ; +if (async_syscall (current)) +return -ENOSYS ; +if (!pid) pid = group_leader->pid;if (!pgid)
@@ -1488,6 +1515,9 @@ asmlinkage long sys_setsid(void)pid_t session;int err = -EPERM ; +if (async_syscall (current)) +return -ENOSYS ; +write_lock_irq (&tasklist_lock);/* Fail if I am already a session leader */
@@ -1732,6 +1762,9 @@ asmlinkage long sys_setgroups(int gidsetstruct group_info *group_info;int retval; +if (async_syscall (current)) +return -ENOSYS ; +if (!capable (CAP_SETGID ))return -EPERM ;if ((unsigned )gidsetsize >NGROUPS_MAX )
@@ -2073,6 +2106,9 @@ asmlinkage long sys_prctl(int option, un {long error; +if (async_syscall (current)) +return -ENOSYS ; + error =security_task_prctl (option, arg2, arg3, arg4, arg5);if (error)return error;
PATCH 4/13 syslets: core code
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
the core syslet / async system calls infrastructure code.
Is built only if CONFIG_ASYNC_SUPPORT is enabled.
--- kernel/Makefile | 1 kernel/async.c | 958 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 959 insertions(+)
kernel/Makefile +1 -0
@@ -10,6 +10,7 @@ obj-y = sched.o fork.o exec_domain.o kthread.o wait.o kfifo.o sys_ni.o posix-cpu-timers.o mutex.o \ hrtimer.o rwsem.o latency.o nsproxy.o srcu.o +obj-$(CONFIG_ASYNC_SUPPORT) += async.o obj-$(CONFIG_STACKTRACE) += stacktrace.o obj-y += time/ obj-$(CONFIG_DEBUG_MUTEXES) += mutex-debug.o
kernel/async.c new file +958 -0
958 lines not on this page · raw message
Re: [patch 04/13] syslets: core code
Quoted 49 lines · Ingo Molnar
kernel/async.c new file +49
-0+asmlinkage long +sys_threadlet_on (unsigned long restore_stack, +unsigned long restore_eip, +struct async_head_user __user *ahu) +{ +struct task_struct *t = current; +struct async_head *ah = t->ah; +struct async_thread *at = &t->__at; +long ret; + +/* +* Do not allow recursive calls of sys_threadlet_on(): +*/ +if (t->async_ready || t->at) +return -EINVAL ; + +if (unlikely (!ah)) { + ret =init_head (ah, t, ahu); +if (ret) +return ret; + ah = t->ah; + } + +if (unlikely (list_empty (&ah->ready_async_threads))) { + ret =refill_cachemiss_pool (ah, t, ahu); +if (ret) +return ret; + } + + t->async_ready = at; + ah->restore_stack = restore_stack; + ah->restore_eip = restore_eip; + + ah->ahu = ahu; + +return 0 ; +} + +asmlinkage long sys_threadlet_off (void ) +{ +struct task_struct *t = current; +struct async_head *ah = t->ah; + +/* +* Are we still executing as head? +*/ +if (ah) { + t->async_ready =NULL ; +
kernel/async.c line 879
Quoted 10 lines
kernel/async.c new file +10
-0+return 1 ; + } + +/* +* We got turned into a cachemiss thread, +* return to user-space, which can do +* the notification, etc: +*/ +return 0 ; +}
If we have a new syscall that does the exec, we can save the two on/off calls. Also, the complete_thread() thingy can be done automatically from inside the kernel upon function return, by hence making the threadlet function look like a normal thread function:
long thfn(void *) {
... return error; }
No?
- Davide
Re: [patch 04/13] syslets: core code
Quoted 9 lines · Davide Libenzi
kernel/async.c line 859
Quoted 6 lines
kernel/async.c new file +5
-0+asmlinkage long +sys_threadlet_on(unsigned long restore_stack, + unsigned long restore_eip, + struct async_head_user __user *ahu) +asmlinkage long sys_threadlet_off(void)If we have a new syscall that does the exec, we can save the two on/off calls.
the on/off calls are shaped in a way that makes them ultimately vsyscall-able - the kernel only needs to know about the fact that we are in a threadlet (so that the scheduler can do its special push-head-to-another-context thing) - and this can be signalled via a small user-space-side info structure as well, put into the TLS.
Quoted 3 lines
[...] Also, the
complete_thread()thingy can be done automatically from inside the kernel upon function return, by hence making the threadlet function look like a normal thread function:
yeah - and that's how it works in my current codebase already, threadlet_off() takes a 'completion event' pointer as well, and the ahu. I'll release v4 so that you can have a look.
Ingo
Re: [patch 04/13] syslets: core code
Quoted 9 lines · Ingo Molnar
Quoted 6 lines · Davide Libenzi
Quoted 6 lines
kernel/async.c new file +5
-0+asmlinkage long +sys_threadlet_on(unsigned long restore_stack, + unsigned long restore_eip, + struct async_head_user __user *ahu) +asmlinkage long sys_threadlet_off(void)
Quoted 8 lines
Quoted 2 lines
If we have a new syscall that does the exec, we can save the two on/off calls.
the on/off calls are shaped in a way that makes them ultimately vsyscall-able - the kernel only needs to know about the fact that we are in a threadlet (so that the scheduler can do its special push-head-to-another-context thing) - and this can be signalled via a small user-space-side info structure as well, put into the TLS.
IMO it's not a matter of speed. We'll have those two new syscalls, that I don't see other practical use for. IMO the best thing would be to hide all inside the sys_threadlet_exec (or whatever name).
Quoted 7 lines
Quoted 3 lines
[...] Also, the
complete_thread()thingy can be done automatically from inside the kernel upon function return, by hence making the threadlet function look like a normal thread function:yeah - and that's how it works in my current codebase already,
threadlet_off()takes a 'completion event' pointer as well, and the ahu. I'll release v4 so that you can have a look.
Ok. Will look into it...
- Davide
Re: [patch 04/13] syslets: core code
Quoted 4 lines · Davide Libenzi
Quoted 1 line · Ingo Molnar
the on/off calls are shaped in a way that makes them ultimately vsyscall-able - the kernel only needs to know about the fact that we are in a threadlet (so that the scheduler can do its special push-head-to-another-context thing) - and this can be signalled via a small user-space-side info structure as well, put into the TLS.
IMO it's not a matter of speed. We'll have those two new syscalls, that I don't see other practical use for. IMO the best thing would be to hide all inside the
sys_threadlet_exec(or whatever name).
No, it absolutely is a matter of speed. The reason to have those two implemented that way is so that they can be implemented as vsyscalls completely in userspace. This means that on most modern platforms you can implement the "make a threadlet when I block" semantic without even touching kernel-mode. The way it's set up all you'd have to do is save some parameters, set up a new callstack, and poke a "1" into a memory address in the TLS. To stop, you effectively just poke a "0" into the spot in the TLS and either return or terminate the thread.
Cheers,
Kyle Moffett
Re: [patch 04/13] syslets: core code
Quoted 12 lines · Kyle Moffett
Quoted 10 lines · Davide Libenzi
Quoted 5 lines · Ingo Molnar
the on/off calls are shaped in a way that makes them ultimately vsyscall-able - the kernel only needs to know about the fact that we are in a threadlet (so that the scheduler can do its special push-head-to-another-context thing) - and this can be signalled via a small user-space-side info structure as well, put into the TLS.
IMO it's not a matter of speed. We'll have those two new syscalls, that I don't see other practical use for. IMO the best thing would be to hide all inside the
sys_threadlet_exec(or whatever name).
Quoted 8 lines
No, it absolutely is a matter of speed. The reason to have those two implemented that way is so that they can be implemented as vsyscalls completely in userspace. This means that on most modern platforms you can implement the "make a threadlet when I block" semantic without even touching kernel-mode. The way it's set up all you'd have to do is save some parameters, set up a new callstack, and poke a "1" into a memory address in the TLS. To stop, you effectively just poke a "0" into the spot in the TLS and either return or terminate the thread.
Right. I don't why but I got the implression Ingo's threadlet_exec example was just sketch code to be moved in a syscall. That's why I was talking about a sys_threadlet_exec. But yeah, it makes a lot of sense to turn threadlet_exec in a glibc thing, and play everything in userspace at that point.
- Davide
Re: [patch 04/13] syslets: core code
Quoted 10 lines · Davide Libenzi
Quoted 9 lines
No, it absolutely is a matter of speed. The reason to have those two implemented that way is so that they can be implemented as vsyscalls completely in userspace. This means that on most modern platforms you can implement the "make a threadlet when I block" semantic without even touching kernel-mode. The way it's set up all you'd have to do is save some parameters, set up a new callstack, and poke a "1" into a memory address in the TLS. To stop, you effectively just poke a "0" into the spot in the TLS and either return or terminate the thread.
Quoted 5 lines
Right. I don't why but I got the implression Ingo's
threadlet_execexample was just sketch code to be moved in a syscall. That's why I was talking about asys_threadlet_exec. But yeah, it makes a lot of sense to turnthreadlet_execin a glibc thing, and play everything in userspace at that point.
yeah, not having to do any extra entry into the kernel at all (in the cached case), and to make them in essence equivalent to a function call is my plan/hope for threadlets :-)
Ingo
PATCH 5/13 syslets: core, documentation
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
Add Documentation/syslet-design.txt with a high-level description of the syslet concepts.
--- Documentation/syslet-design.txt | 137 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+)
Documentation/syslet-design.txt new file +137 -0
@@ -0,0 +1,137 @@ +Syslets / asynchronous system calls +=================================== + +started by Ingo Molnar <[email protected]> + +Goal: +----- + +The goal of the syslet subsystem is to allow user-space to execute +arbitrary system calls asynchronously. It does so by allowing user-space +to execute "syslets" which are small scriptlets that the kernel can execute +both securely and asynchronously without having to exit to user-space. + +the core syslet concepts are: + +The Syslet Atom: +---------------- + +The syslet atom is a small, fixed-size (44 bytes on 32-bit) piece of +user-space memory, which is the basic unit of execution within the syslet +framework. A syslet represents a single system-call and its arguments. +In addition it also has condition flags attached to it that allows the +construction of larger programs (syslets) from these atoms. + +Arguments to the system call are implemented via pointers to arguments. +This not only increases the flexibility of syslet atoms (multiple syslets +can share the same variable for example), but is also an optimization: +copy_uatom() will only fetch syscall parameters up until the point it +meets the first NULL pointer. 50% of all syscalls have 2 or less +parameters (and 90% of all syscalls have 4 or less parameters). + + [ Note: since the argument array is at the end of the atom, and the + kernel will not touch any argument beyond the final NULL one, atoms + might be packed more tightly. (the only special case exception to + this rule would be SKIP_TO_NEXT_ON_STOP atoms, where the kernel will + jump a full syslet_uatom number of bytes.) ] + +The Syslet: +----------- + +A syslet is a program, represented by a graph of syslet atoms. The +syslet atoms are chained to each other either via the atom->next pointer, +or via the SYSLET_SKIP_TO_NEXT_ON_STOP flag. + +Running Syslets: +---------------- + +Syslets can be run via the sys_async_exec() system call, which takes +the first atom of the syslet as an argument. The kernel does not need +to be told about the other atoms - it will fetch them on the fly as +execution goes forward. + +A syslet might either be executed 'cached', or it might generate a +'cachemiss'. + +'Cached' syslet execution means that the whole syslet was executed +without blocking. The system-call returns the submitted atom's address +in this case. + +If a syslet blocks while the kernel executes a system-call embedded in +one of its atoms, the kernel will keep working on that syscall in +parallel, but it immediately returns to user-space with a NULL pointer, +so the submitting task can submit other syslets. + +Completion of asynchronous syslets: +----------------------------------- + +Completion of asynchronous syslets is done via the 'completion ring', +which is a ringbuffer of syslet atom pointers user user-space memory, +provided by user-space as an argument to the sys_async_exec() syscall. +The kernel fills in the ringbuffer starting at index 0, and user-space +must clear out these pointers. Once the kernel reaches the end of +the ring it wraps back to index 0. The kernel will not overwrite +non-NULL pointers (but will return an error), user-space has to +make sure it completes all events it asked for. + +Waiting for completions: +------------------------ + +Syslet completions can be waited for via the sys_async_wait() +system call - which takes the number of events it should wait for as +a parameter. This system call will also return if the number of +pending events goes down to zero. + +Sample Hello World syslet code: + +---------------------------> +/* + * Set up a syslet atom: + */ +static void +init_atom(struct syslet_uatom *atom, int nr, + void *arg_ptr0, void *arg_ptr1, void *arg_ptr2, + void *arg_ptr3, void *arg_ptr4, void *arg_ptr5, + void *ret_ptr, unsigned long flags, struct syslet_uatom *next) +{ + atom->nr = nr; + atom->arg_ptr[0] = arg_ptr0; + atom->arg_ptr[1] = arg_ptr1; + atom->arg_ptr[2] = arg_ptr2; + atom->arg_ptr[3] = arg_ptr3; + atom->arg_ptr[4] = arg_ptr4; + atom->arg_ptr[5] = arg_ptr5; + atom->ret_ptr = ret_ptr; + atom->flags = flags; + atom->next = next; +} + +int main(int argc, char *argv[]) +{ + unsigned long int fd_out = 1; /* standard output */ + char *buf = "Hello Syslet World!\n"; + unsigned long size = strlen(buf); + struct syslet_uatom atom, *done; + + async_head_init(); + + /* + * Simple syslet consisting of a single atom: + */ + init_atom(&atom, __NR_sys_write, &fd_out, &buf, &size, + NULL, NULL, NULL, NULL, SYSLET_ASYNC, NULL); + done = sys_async_exec(&atom); + if (!done) { + sys_async_wait(1); + if (completion_ring[curr_ring_idx] == &atom) { + completion_ring[curr_ring_idx] = NULL; + printf("completed an async syslet atom!\n"); + } + } else { + printf("completed an cached syslet atom!\n"); + } + + async_head_exit(); + + return 0; +}
Re: [patch 05/13] syslets: core, documentation
Quoted 4 lines · On Wed, 21 Feb 2007 22:15:21 +0100 Ingo Molnar wrote:
From: Ingo Molnar <[email protected]>
Add
Documentation/syslet-design.txtwith a high-level description of the syslet concepts.
Just a few comments & questions...
Quoted 24 lines
Signed-off-by Ingo Molnar <[email protected]>Signed-off-by Arjan van de Ven <[email protected]>--- Documentation/syslet-design.txt | 137 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 137 insertions(+)Index:
linux/Documentation/syslet-design.txt
===================================================================Documentation/syslet-design.txt new file +13
-0@@ -0,0 +1,137 @@ +Syslets / asynchronous system calls +=================================== + +the core syslet concepts are: + +The Syslet Atom: +---------------- + +The syslet atom is a small, fixed-size (44 bytes on 32-bit) piece of +user-space memory, which is the basic unit of execution within the syslet +framework. A syslet represents a single system-call and its arguments. +In addition it also has condition flags attached to it that allows the +construction of larger programs (syslets) from these atoms.
Documentation/syslet-design.txt line 23
Quoted 10 lines
Documentation/syslet-design.txt new file +10
-0+ +Arguments to the system call are implemented via pointers to arguments. +This not only increases the flexibility of syslet atoms (multiple syslets +can share the same variable for example), but is also an optimization: +copy_uatom() will only fetch syscall parameters up until the point it +meets the first NULL pointer. 50% of all syscalls have 2 or less +parameters (and 90% of all syscalls have 4 or less parameters). + + [ Note: since the argument array is at the end of the atom, and the + kernel will not touch any argument beyond the final NULL one, atoms
I would s/final/first/ since one could put many (unneeded) NULL pointers in the argument array.
Quoted 3 lines
Documentation/syslet-design.txt new file +3
-0+ might be packed more tightly. (the only special case exception to + this rule would be SKIP_TO_NEXT_ON_STOP atoms, where the kernel will + jump a full syslet_uatom number of bytes.) ]
...
Documentation/syslet-design.txt line 69
Quoted 5 lines
Documentation/syslet-design.txt new file +5
-0+Completion of asynchronous syslets: +----------------------------------- + +Completion of asynchronous syslets is done via the 'completion ring', +which is a ringbuffer of syslet atom pointers user user-space memory,
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^^^^ ^^^^ ??
Documentation/syslet-design.txt line 75
Quoted 6 lines
Documentation/syslet-design.txt new file +6
-0+provided by user-space as an argument to the sys_async_exec() syscall. +The kernel fills in the ringbuffer starting at index 0, and user-space +must clear out these pointers. Once the kernel reaches the end of +the ring it wraps back to index 0. The kernel will not overwrite +non-NULL pointers (but will return an error), user-space has to +make sure it completes all events it asked for.
Last sentence is actually 2 sentences, so (e.g.) change the comma to a semi-colon, xor begin the sentence with "Since".
How does the kernel return an error if the ring buffer is full? Just a syscall negative error return code?
Quoted 4 lines
Documentation/syslet-design.txt new file +4
-0+int main(int argc, char *argv[]) +{ + unsigned long int fd_out = 1; /* standard output */ + char *buf = "Hello Syslet World!\n";
Documentation/syslet-design.txt line 122
Quoted 10 lines
Documentation/syslet-design.txt new file +10
-0+ unsigned long size = strlen(buf); + struct syslet_uatom atom, *done; + + async_head_init(); + + /* + * Simple syslet consisting of a single atom: + */ + init_atom(&atom, __NR_sys_write, &fd_out, &buf, &size, + NULL, NULL, NULL, NULL, SYSLET_ASYNC, NULL);
init_atom() (was) above. sys_async_exec(), sys_async_wait() are new syscalls. What are async_head_init() and async_head_exit()?
Quoted 5 lines
Documentation/syslet-design.txt new file +5
-0+ done = sys_async_exec(&atom); + if (!done) { + sys_async_wait(1); + if (completion_ring[curr_ring_idx] == &atom) { + completion_ring[curr_ring_idx] = NULL;
Documentation/syslet-design.txt line 137
Quoted 10 lines
Documentation/syslet-design.txt new file +10
-0+ printf("completed an async syslet atom!\n"); + } + } else { + printf("completed an cached syslet atom!\n"); + } + + async_head_exit(); + + return 0; +}
---
~Randy
*** Remember to use Documentation/SubmitChecklist when testing your code ***
Re: [patch 05/13] syslets: core, documentation
Quoted 5 lines · Randy Dunlap
Quoted 2 lines
+ [ Note: since the argument array is at the end of the atom, and the
+ kernel will not touch any argument beyond the final NULL one, atomsI would s/final/first/ since one could put many (unneeded) NULL pointers in the argument array.
ok, fixed.
Quoted 4 lines
Documentation/syslet-design.txt line 69
Quoted 2 lines
Documentation/syslet-design.txt new file +2
-0+Completion of asynchronous syslets is done via the 'completion ring', +which is a ringbuffer of syslet atom pointers user user-space memory,~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ^^^^ ^^^^ ??
fixed - it's "in user-space memory".
Quoted 9 lines
Documentation/syslet-design.txt line 75
Quoted 6 lines
Documentation/syslet-design.txt new file +6
-0+provided by user-space as an argument to the sys_async_exec() syscall. +The kernel fills in the ringbuffer starting at index 0, and user-space +must clear out these pointers. Once the kernel reaches the end of +the ring it wraps back to index 0. The kernel will not overwrite +non-NULL pointers (but will return an error), user-space has to +make sure it completes all events it asked for.Last sentence is actually 2 sentences, so (e.g.) change the comma to a semi-colon, xor begin the sentence with "Since".
i've changed it to ', and thus user-space has to make sure'.
Quoted 2 lines
How does the kernel return an error if the ring buffer is full? Just a syscall negative error return code?
correct - we return a -EFAULT in that case. Should probably do something more distinguished though?
Quoted 8 lines
Documentation/syslet-design.txt line 122
Quoted 5 lines
Documentation/syslet-design.txt new file +5
-0+ /* + * Simple syslet consisting of a single atom: + */ + init_atom(&atom, __NR_sys_write, &fd_out, &buf, &size, + NULL, NULL, NULL, NULL, SYSLET_ASYNC, NULL);
init_atom()(was) above.sys_async_exec(),sys_async_wait()are new syscalls. What areasync_head_init()andasync_head_exit()?
They used to initialize kernel-side stuff too, but now they only initialize the user-space-head structure: the ring and a 'head stack pointer'.
Ingo
PATCH 6/13 x86: split FPU state from task state
In reply to Ingo MolnarFrom: Arjan van de Ven <[email protected]>
Split the FPU save area from the task struct. This allows easy migration of FPU context, and it's generally cleaner. It also allows the following two (future) optimizations:
1) allocate the right size for the actual cpu rather than 512 bytes always
2) only allocate when the application actually uses FPU, so in the first lazy FPU trap. This could save memory for non-fpu using apps.
--- arch/i386/kernel/i387.c | 96 ++++++++++++++++++++--------------------- arch/i386/kernel/process.c | 56 +++++++++++++++++++++++ arch/i386/kernel/traps.c | 10 ---- include/asm-i386/i387.h | 6 +- include/asm-i386/processor.h | 6 ++ include/asm-i386/thread_info.h | 6 ++ kernel/fork.c | 7 ++ 7 files changed, 123 insertions(+), 64 deletions(-)
arch/i386/kernel/i387.c +48 -48
@@ -31,9 +31,9 @@ void mxcsr_feature_mask_init(void)unsigned long mask =0 ;clts ();if (cpu_has_fxsr) { -memset (¤t->thread.i387.fxsave,0 ,sizeof (struct i387_fxsave_struct )); - asmvolatile ("fxsave %0" : :"m" (current->thread.i387.fxsave)); - mask = current->thread.i387.fxsave.mxcsr_mask; +memset (¤t->thread.i387->fxsave,0 ,sizeof (struct i387_fxsave_struct )); + asmvolatile ("fxsave %0" : :"m" (current->thread.i387->fxsave)); + mask = current->thread.i387->fxsave.mxcsr_mask;if (mask ==0 ) mask =0x0000ffbf ; } mxcsr_feature_mask &= mask;
@@ -49,16 +49,16 @@ void mxcsr_feature_mask_init(void)void init_fpu (struct task_struct *tsk) {if (cpu_has_fxsr) { -memset (&tsk->thread.i387.fxsave,0 ,sizeof (struct i387_fxsave_struct )); - tsk->thread.i387.fxsave.cwd =0x37f ; +memset (&tsk->thread.i387->fxsave,0 ,sizeof (struct i387_fxsave_struct )); + tsk->thread.i387->fxsave.cwd =0x37f ;if (cpu_has_xmm) - tsk->thread.i387.fxsave.mxcsr =0x1f80 ; + tsk->thread.i387->fxsave.mxcsr =0x1f80 ; }else { -memset (&tsk->thread.i387.fsave,0 ,sizeof (struct i387_fsave_struct )); - tsk->thread.i387.fsave.cwd =0xffff037fu ; - tsk->thread.i387.fsave.swd =0xffff0000u ; - tsk->thread.i387.fsave.twd =0xffffffffu ; - tsk->thread.i387.fsave.fos =0xffff0000u ; +memset (&tsk->thread.i387->fsave,0 ,sizeof (struct i387_fsave_struct )); + tsk->thread.i387->fsave.cwd =0xffff037fu ; + tsk->thread.i387->fsave.swd =0xffff0000u ; + tsk->thread.i387->fsave.twd =0xffffffffu ; + tsk->thread.i387->fsave.fos =0xffff0000u ; }/* only the device not available exception or ptrace can call init_fpu */ set_stopped_child_used_math (tsk);
@@ -152,18 +152,18 @@ static inline unsigned long twd_fxsr_to_unsigned short get_fpu_cwd (struct task_struct *tsk ) {if ( cpu_has_fxsr ) { -return tsk->thread.i387.fxsave.cwd; +return tsk->thread.i387->fxsave.cwd; }else { -return (unsigned short )tsk->thread.i387.fsave.cwd; +return (unsigned short )tsk->thread.i387->fsave.cwd; } }unsigned short get_fpu_swd (struct task_struct *tsk ) {if ( cpu_has_fxsr ) { -return tsk->thread.i387.fxsave.swd; +return tsk->thread.i387->fxsave.swd; }else { -return (unsigned short )tsk->thread.i387.fsave.swd; +return (unsigned short )tsk->thread.i387->fsave.swd; } }
@@ -171,9 +171,9 @@ unsigned short get_fpu_swd( struct task_unsigned short get_fpu_twd (struct task_struct *tsk ) {if ( cpu_has_fxsr ) { -return tsk->thread.i387.fxsave.twd; +return tsk->thread.i387->fxsave.twd; }else { -return (unsigned short )tsk->thread.i387.fsave.twd; +return (unsigned short )tsk->thread.i387->fsave.twd; } }#endif /* 0 */
@@ -181,7 +181,7 @@ unsigned short get_fpu_twd( struct task_unsigned short get_fpu_mxcsr (struct task_struct *tsk ) {if ( cpu_has_xmm ) { -return tsk->thread.i387.fxsave.mxcsr; +return tsk->thread.i387->fxsave.mxcsr; }else {return 0x1f80 ; }
@@ -192,27 +192,27 @@ unsigned short get_fpu_mxcsr( struct tasvoid set_fpu_cwd (struct task_struct *tsk,unsigned short cwd ) {if ( cpu_has_fxsr ) { - tsk->thread.i387.fxsave.cwd = cwd; + tsk->thread.i387->fxsave.cwd = cwd; }else { - tsk->thread.i387.fsave.cwd = ((long )cwd |0xffff0000u ); + tsk->thread.i387->fsave.cwd = ((long )cwd |0xffff0000u ); } }void set_fpu_swd (struct task_struct *tsk,unsigned short swd ) {if ( cpu_has_fxsr ) { - tsk->thread.i387.fxsave.swd = swd; + tsk->thread.i387->fxsave.swd = swd; }else { - tsk->thread.i387.fsave.swd = ((long )swd |0xffff0000u ); + tsk->thread.i387->fsave.swd = ((long )swd |0xffff0000u ); } }void set_fpu_twd (struct task_struct *tsk,unsigned short twd ) {if ( cpu_has_fxsr ) { - tsk->thread.i387.fxsave.twd =twd_i387_to_fxsr (twd); + tsk->thread.i387->fxsave.twd =twd_i387_to_fxsr (twd); }else { - tsk->thread.i387.fsave.twd = ((long )twd |0xffff0000u ); + tsk->thread.i387->fsave.twd = ((long )twd |0xffff0000u ); } }
@@ -298,8 +298,8 @@ static inline int save_i387_fsave( strucstruct task_struct *tsk = current;unlazy_fpu ( tsk ); - tsk->thread.i387.fsave.status = tsk->thread.i387.fsave.swd; -if (__copy_to_user ( buf, &tsk->thread.i387.fsave, + tsk->thread.i387->fsave.status = tsk->thread.i387->fsave.swd; +if (__copy_to_user ( buf, &tsk->thread.i387->fsave,sizeof (struct i387_fsave_struct ) ) )return -1 ;return 1 ;
@@ -312,15 +312,15 @@ static int save_i387_fxsave( struct _fpsunlazy_fpu ( tsk ); -if (convert_fxsr_to_user ( buf, &tsk->thread.i387.fxsave ) ) +if (convert_fxsr_to_user ( buf, &tsk->thread.i387->fxsave ) )return -1 ; - err |=__put_user ( tsk->thread.i387.fxsave.swd, &buf->status ); + err |=__put_user ( tsk->thread.i387->fxsave.swd, &buf->status ); err |=__put_user (X86_FXSR_MAGIC , &buf->magic );if ( err )return -1 ; -if (__copy_to_user ( &buf->_fxsr_env[0 ], &tsk->thread.i387.fxsave, +if (__copy_to_user ( &buf->_fxsr_env[0 ], &tsk->thread.i387->fxsave,sizeof (struct i387_fxsave_struct ) ) )return -1 ;return 1 ;
@@ -343,7 +343,7 @@ int save_i387( struct _fpstate __user *breturn save_i387_fsave ( buf ); } }else { -return save_i387_soft ( ¤t->thread.i387.soft, buf ); +return save_i387_soft ( ¤t->thread.i387->soft, buf ); } }
@@ -351,7 +351,7 @@ static inline int restore_i387_fsave( st {struct task_struct *tsk = current;clear_fpu ( tsk ); -return __copy_from_user ( &tsk->thread.i387.fsave, buf, +return __copy_from_user ( &tsk->thread.i387->fsave, buf,sizeof (struct i387_fsave_struct ) ); }
@@ -360,11 +360,11 @@ static int restore_i387_fxsave( struct _int err;struct task_struct *tsk = current;clear_fpu ( tsk ); - err =__copy_from_user ( &tsk->thread.i387.fxsave, &buf->_fxsr_env[0 ], + err =__copy_from_user ( &tsk->thread.i387->fxsave, &buf->_fxsr_env[0 ],sizeof (struct i387_fxsave_struct ) );/* mxcsr reserved bits must be masked to zero for security reasons */ - tsk->thread.i387.fxsave.mxcsr &= mxcsr_feature_mask; -return err ?1 :convert_fxsr_from_user ( &tsk->thread.i387.fxsave, buf ); + tsk->thread.i387->fxsave.mxcsr &= mxcsr_feature_mask; +return err ?1 :convert_fxsr_from_user ( &tsk->thread.i387->fxsave, buf ); }int restore_i387 (struct _fpstate __user *buf )
@@ -378,7 +378,7 @@ int restore_i387( struct _fpstate __user err =restore_i387_fsave ( buf ); } }else { - err =restore_i387_soft ( ¤t->thread.i387.soft, buf ); + err =restore_i387_soft ( ¤t->thread.i387->soft, buf ); }set_used_math ();return err;
@@ -391,7 +391,7 @@ int restore_i387( struct _fpstate __userstatic inline int get_fpregs_fsave (struct user_i387_struct __user *buf,struct task_struct *tsk ) { -return __copy_to_user ( buf, &tsk->thread.i387.fsave, +return __copy_to_user ( buf, &tsk->thread.i387->fsave,sizeof (struct user_i387_struct ) ); }
@@ -399,7 +399,7 @@ static inline int get_fpregs_fxsave( str struct task_struct *tsk ) {return convert_fxsr_to_user ( (struct _fpstate __user *)buf, - &tsk->thread.i387.fxsave ); + &tsk->thread.i387->fxsave ); }int get_fpregs (struct user_i387_struct __user *buf,struct task_struct *tsk )
@@ -411,7 +411,7 @@ int get_fpregs( struct user_i387_structreturn get_fpregs_fsave ( buf, tsk ); } }else { -return save_i387_soft ( &tsk->thread.i387.soft, +return save_i387_soft ( &tsk->thread.i387->soft, (struct _fpstate __user *)buf ); } }
@@ -419,14 +419,14 @@ int get_fpregs( struct user_i387_structstatic inline int set_fpregs_fsave (struct task_struct *tsk,struct user_i387_struct __user *buf ) { -return __copy_from_user ( &tsk->thread.i387.fsave, buf, +return __copy_from_user ( &tsk->thread.i387->fsave, buf,sizeof (struct user_i387_struct ) ); }static inline int set_fpregs_fxsave (struct task_struct *tsk,struct user_i387_struct __user *buf ) { -return convert_fxsr_from_user ( &tsk->thread.i387.fxsave, +return convert_fxsr_from_user ( &tsk->thread.i387->fxsave, (struct _fpstate __user *)buf ); }
@@ -439,7 +439,7 @@ int set_fpregs( struct task_struct *tsk,return set_fpregs_fsave ( tsk, buf ); } }else { -return restore_i387_soft ( &tsk->thread.i387.soft, +return restore_i387_soft ( &tsk->thread.i387->soft, (struct _fpstate __user *)buf ); } }
@@ -447,7 +447,7 @@ int set_fpregs( struct task_struct *tsk,int get_fpxregs (struct user_fxsr_struct __user *buf,struct task_struct *tsk ) {if ( cpu_has_fxsr ) { -if (__copy_to_user ( buf, &tsk->thread.i387.fxsave, +if (__copy_to_user ( buf, &tsk->thread.i387->fxsave,sizeof (struct user_fxsr_struct ) ))return -EFAULT ;return 0 ;
@@ -461,11 +461,11 @@ int set_fpxregs( struct task_struct *tskint ret =0 ;if ( cpu_has_fxsr ) { -if (__copy_from_user ( &tsk->thread.i387.fxsave, buf, +if (__copy_from_user ( &tsk->thread.i387->fxsave, buf,sizeof (struct user_fxsr_struct ) )) ret = -EFAULT ;/* mxcsr reserved bits must be masked to zero for security reasons */ - tsk->thread.i387.fxsave.mxcsr &= mxcsr_feature_mask; + tsk->thread.i387->fxsave.mxcsr &= mxcsr_feature_mask; }else { ret = -EIO ; }
@@ -479,7 +479,7 @@ int set_fpxregs( struct task_struct *tskstatic inline void copy_fpu_fsave (struct task_struct *tsk,struct user_i387_struct *fpu ) { -memcpy ( fpu, &tsk->thread.i387.fsave, +memcpy ( fpu, &tsk->thread.i387->fsave,sizeof (struct user_i387_struct ) ); }
@@ -490,10 +490,10 @@ static inline void copy_fpu_fxsave( struunsigned short *from;int i; -memcpy ( fpu, &tsk->thread.i387.fxsave,7 *sizeof (long ) ); +memcpy ( fpu, &tsk->thread.i387->fxsave,7 *sizeof (long ) ); to = (unsigned short *)&fpu->st_space[0 ]; - from = (unsigned short *)&tsk->thread.i387.fxsave.st_space[0 ]; + from = (unsigned short *)&tsk->thread.i387->fxsave.st_space[0 ];for ( i =0 ; i <8 ; i++, to +=5 , from +=8 ) {memcpy ( to, from,5 *sizeof (unsigned short ) ); }
@@ -540,7 +540,7 @@ int dump_task_extended_fpu(struct task_sif (fpvalid) {if (tsk == current)unlazy_fpu (tsk); -memcpy (fpu, &tsk->thread.i387.fxsave,sizeof (*fpu)); +memcpy (fpu, &tsk->thread.i387->fxsave,sizeof (*fpu)); }return fpvalid; }
arch/i386/kernel/process.c +55 -1
65 lines not on this page · raw message
arch/i386/kernel/traps.c +0 -10
@@ -1154,16 +1154,6 @@ void __init trap_init(void)set_trap_gate (19 ,&simd_coprocessor_error);if (cpu_has_fxsr) { -/* -* Verify that the FXSAVE/FXRSTOR data will be 16-byte aligned. -* Generates a compile-time "error: zero width for bit-field" if -* the alignment is wrong. -*/ -struct fxsrAlignAssert { -int _:!(offsetof(struct task_struct , - thread.i387.fxsave) & 15); - }; -printk (KERN_INFO "Enabling fast FPU save and restore... " );set_in_cr4 (X86_CR4_OSFXSR );printk ("done.\n" );
include/asm-i386/i387.h +3 -3
@@ -34,7 +34,7 @@ extern void init_fpu(struct task_struct "nop ; frstor %1", \ "fxrstor %1", \ X86_FEATURE_FXSR, \ - "m" ((tsk)->thread.i387.fxsave)) + "m" ((tsk)->thread.i387->fxsave))extern void kernel_fpu_begin (void );#define kernel_fpu_end () do { stts(); preempt_enable(); } while(0)
@@ -60,8 +60,8 @@ static inline void __save_init_fpu( stru"fxsave %[fx]\n" "bt $7,%[fsw] ; jnc 1f ; fnclex\n1:" , X86_FEATURE_FXSR, - [fx] "m" (tsk->thread.i387.fxsave), - [fsw] "m" (tsk->thread.i387.fxsave.swd) : "memory"); + [fx] "m" (tsk->thread.i387->fxsave), + [fsw] "m" (tsk->thread.i387->fxsave.swd) : "memory");/* AMD K7/K8 CPUs don't save/restore FDP/FIP/FOP unless an exception is pending. Clear the x87 state here by setting it to fixed values. safe_address is a random variable that should be in L1 */
include/asm-i386/processor.h +5 -1
@@ -407,7 +407,7 @@ struct thread_struct {/* fault info */ unsigned long cr2, trap_no, error_code;/* floating point info */ -union i387_union i387; +union i387_union *i387;/* virtual 86 mode info */ struct vm86_struct __user * vm86_info;unsigned long screen_bitmap;
@@ -420,11 +420,15 @@ struct thread_struct {unsigned long io_bitmap_max; }; + +extern union i387_union init_i387_context; +#define INIT_THREAD { \ .vm86_info = NULL, \ .sysenter_cs = __KERNEL_CS, \ .io_bitmap_ptr = NULL, \ .gs = __KERNEL_PDA, \ + .i387 = &init_i387_context, \ }/*
include/asm-i386/thread_info.h +6 -0
@@ -102,6 +102,12 @@ static inline struct thread_info *curren#define free_thread_info (info) kfree(info) +#define __HAVE_ARCH_TASK_STRUCT_ALLOCATOR +extern struct task_struct *alloc_task_struct (void ); +extern void free_task_struct (struct task_struct *tsk); +extern void memcpy_task_struct (struct task_struct *dst,struct task_struct *src); +extern void task_struct_slab_init (void ); +#else /* !__ASSEMBLY__ */ /* how to get the thread information struct from ASM */
kernel/fork.c +6 -1
@@ -84,6 +84,8 @@ int nr_processes(void)#ifndef __HAVE_ARCH_TASK_STRUCT_ALLOCATOR# define alloc_task_struct () kmem_cache_alloc(task_struct_cachep, GFP_KERNEL)# define free_task_struct (tsk) kmem_cache_free(task_struct_cachep, (tsk)) +# define memcpy_task_struct (dst, src) *dst = *src; +static struct kmem_cache *task_struct_cachep;#endif
@@ -138,6 +140,8 @@ void __init fork_init(unsigned long memp task_struct_cachep =kmem_cache_create ("task_struct" ,sizeof (struct task_struct ),ARCH_MIN_TASKALIGN ,SLAB_PANIC ,NULL ,NULL ); +#else +task_struct_slab_init ();#endif /*
@@ -176,7 +180,8 @@ static struct task_struct *dup_task_strureturn NULL ; } - *tsk = *orig; +memcpy_task_struct (tsk, orig); + tsk->thread_info = ti;setup_thread_stack (tsk, orig);
PATCH 7/13 syslets: x86, add create_async_thread() method
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
add the create_async_thread() way of creating kernel threads:
these threads first execute a kernel function and when they return from it they execute user-space.
An architecture must implement this interface before it can turn CONFIG_ASYNC_SUPPORT on.
--- arch/i386/kernel/entry.S | 25 +++++++++++++++++++++++++ arch/i386/kernel/process.c | 31 +++++++++++++++++++++++++++++++ include/asm-i386/processor.h | 5 +++++ 3 files changed, 61 insertions(+)
arch/i386/kernel/entry.S +25 -0
@@ -996,6 +996,31 @@ ENTRY(kernel_thread_helper) CFI_ENDPROC ENDPROC(kernel_thread_helper) +ENTRY(async_thread_helper) + CFI_STARTPROC + /* + * Allocate space on the stack for pt-regs. + * sizeof(struct pt_regs) == 64, and we've got 8 bytes on the + * kernel stack already: + */ + subl $64-8, %esp + CFI_ADJUST_CFA_OFFSET 64 + movl %edx,%eax + push %edx + CFI_ADJUST_CFA_OFFSET 4 + call *%ebx + addl $4, %esp + CFI_ADJUST_CFA_OFFSET -4 + + movl %eax, PT_EAX(%esp) + + GET_THREAD_INFO(%ebp) + + jmp syscall_exit + CFI_ENDPROC +ENDPROC(async_thread_helper) + + .section .rodata,"a" #include "syscall_table.S"
arch/i386/kernel/process.c +31 -0
@@ -352,6 +352,37 @@ int kernel_thread(int (*fn)(void *), voiEXPORT_SYMBOL (kernel_thread);/* +* This gets run with %ebx containing the +* function to call, and %edx containing +* the "args". +*/ +extern void async_thread_helper (void ); + +/* +* Create an async thread +*/ +int create_async_thread (int (*fn)(void *),void * arg,unsigned long flags) +{ +struct pt_regs regs; + +memset (®s,0 ,sizeof (regs)); + + regs.ebx = (unsigned long ) fn; + regs.edx = (unsigned long ) arg; + + regs.xds = __USER_DS; + regs.xes = __USER_DS; + regs.xgs = __KERNEL_PDA; + regs.orig_eax =-1 ; + regs.eip = (unsigned long ) async_thread_helper; + regs.xcs = __KERNEL_CS |get_kernel_rpl (); + regs.eflags =X86_EFLAGS_IF |X86_EFLAGS_SF |X86_EFLAGS_PF |0x2 ; + +/* Ok, create the new task.. */ +return do_fork (flags,0 , ®s,0 ,NULL ,NULL ); +} + +/* * Free current thread data structures etc.. */ void exit_thread (void )
include/asm-i386/processor.h +5 -0
@@ -472,6 +472,11 @@ extern void prepare_to_copy(struct task_*/ extern int kernel_thread (int (*fn)(void *),void * arg,unsigned long flags); +/* +* create an async thread: +*/ +extern int create_async_thread (int (*fn)(void *),void * arg,unsigned long flags); +extern unsigned long thread_saved_pc (struct task_struct *tsk);void show_trace (struct task_struct *task,struct pt_regs *regs,unsigned long *stack);
PATCH 8/13 syslets: x86, add move_user_context() method
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
add the move_user_context() method to move the user-space context of one kernel thread to another kernel thread. User-space might notice the changed TID, but execution, stack and register contents (general purpose and FPU) are still the same.
An architecture must implement this interface before it can turn CONFIG_ASYNC_SUPPORT on.
--- arch/i386/kernel/process.c | 21 +++++++++++++++++++++ include/asm-i386/system.h | 7 +++++++ 2 files changed, 28 insertions(+)
arch/i386/kernel/process.c +21 -0
@@ -820,6 +820,27 @@ unsigned long get_wchan(struct task_stru }/* +* Move user-space context from one kernel thread to another. +* This includes registers and FPU state. Callers must make +* sure that neither task is running user context at the moment: +*/ +void +move_user_context (struct task_struct *new_task,struct task_struct *old_task) +{ +struct pt_regs *old_regs =task_pt_regs (old_task); +struct pt_regs *new_regs =task_pt_regs (new_task); +union i387_union *tmp; + + *new_regs = *old_regs; +/* +* Flip around the FPU state too: +*/ + tmp = new_task->thread.i387; + new_task->thread.i387 = old_task->thread.i387; + old_task->thread.i387 = tmp; +} + +/* * sys_alloc_thread_area: get a yet unused TLS descriptor index. */ static int get_free_idx (void )
include/asm-i386/system.h +7 -0
@@ -33,6 +33,13 @@ extern struct task_struct * FASTCALL(__s "2" (prev), "d" (next)); \ }while (0 ) +/* +* Move user-space context from one kernel thread to another. +* This includes registers and FPU state for now: +*/ +extern void +move_user_context (struct task_struct *new_task,struct task_struct *old_task); +#define _set_base (addr,base) do { unsigned long __pr; \ __asm__ __volatile__ ("movw %%dx,%1\n\t" \ "rorl $16,%%edx\n\t" \
Re: [patch 08/13] syslets: x86, add move_user_context() method
Quoted 7 lines · Ingo Molnar
From: Ingo Molnar <[email protected]>
add the
move_user_context()method to move the user-space context of one kernel thread to another kernel thread. User-space might notice the changed TID, but execution, stack and register contents (general purpose and FPU) are still the same.
Also signal handling should/must be maintained, on top of TID. You don't want the user to be presented with a different signal handling after an sys_async_exec call.
Quoted 24 lines
Signed-off-by Ingo Molnar <[email protected]>Signed-off-by Arjan van de Ven <[email protected]>--- arch/i386/kernel/process.c | 21 +++++++++++++++++++++ include/asm-i386/system.h | 7 +++++++ 2 files changed, 28 insertions(+)Index:
linux/arch/i386/kernel/process.c
===================================================================arch/i386/kernel/process.c +9
-0@@ -820,6 +820,27 @@ unsigned long get_wchan(struct task_stru }/* +* Move user-space context from one kernel thread to another. +* This includes registers and FPU state. Callers must make +* sure that neither task is running user context at the moment: +*/ +void +move_user_context (struct task_struct *new_task,struct task_struct *old_task) +{ +struct pt_regs *old_regs =task_pt_regs (old_task); +struct pt_regs *new_regs =task_pt_regs (new_task);
arch/i386/kernel/process.c unsigned long get_wchan(struct task_stru · line 841
Quoted 10 lines
arch/i386/kernel/process.c +10
-0+union i387_union *tmp; + + *new_regs = *old_regs; +/* +* Flip around the FPU state too: +*/ + tmp = new_task->thread.i387; + new_task->thread.i387 = old_task->thread.i387; + old_task->thread.i387 = tmp; +}
This is not going to work in this case (already posted twice in other emails):
---
Given TS_USEDFPU set (NTSK == new_task, OTSK == old_task), before move_user_context():
CPU => FPUc
NTSK => FPUn
OTSK => FPUo
After move_user_context():
CPU => FPUc
NTSK => FPUo
OTSK => FPUn
After the incoming __unlazy_fpu() in __switch_to():
CPU => FPUc
NTSK => FPUo
OTSK => FPUc
After the first fault in NTSK:
CPU => FPUo
NTSK => FPUo
OTSK => FPUc
So NTSK loads a non up2date FPUo, instead of the FPUc that was the "dirty" context to migrate (since TS_USEDFPU was set). I think you need an early __unlazy_fpu() in that case, that would turn the above into:
Before move_user_context():
CPU => FPUc
NTSK => FPUn
OTSK => FPUo
After an early __unlazy_fpu() before FPU member swap:
CPU => FPUc
NTSK => FPUn
OTSK => FPUc
After move_user_context():
CPU => FPUc
NTSK => FPUc
OTSK => FPUn
After the first fault in NTSK:
CPU => FPUc
NTSK => FPUc
OTSK => FPUn
So, NTSK (the return-to-userspace task) will get the correct FPUc after a fault. But the OTSK (now becoming service thread) will load FPUn after a fault, that is not what expected. You may need a copy in that case. I think correct FPU context handling is not going to be as easy as swapping FPU pointers.
- Davide
Re: [patch 08/13] syslets: x86, add move_user_context() method
Quoted 10 lines · Davide Libenzi
Quoted 7 lines · Ingo Molnar
From: Ingo Molnar <[email protected]>
add the
move_user_context()method to move the user-space context of one kernel thread to another kernel thread. User-space might notice the changed TID, but execution, stack and register contents (general purpose and FPU) are still the same.
Quoted 3 lines
Also signal handling should/must be maintained, on top of TID. You don't want the user to be presented with a different signal handling after an
sys_async_execcall.
right now CLONE_SIGNAL and CLONE_SIGHAND is used for new async threads, so they should inherit and share all the signal settings.
one area that definitely needs more work is that the ptrace parent (if any) should probably follow the 'head' context. gdb at the moment copes surprisingly well, but some artifacts are visible every now and then.
Quoted 11 lines
arch/i386/kernel/process.c unsigned long get_wchan(struct task_stru · line 841
Quoted 8 lines
arch/i386/kernel/process.c +8
-0+ *new_regs = *old_regs; +/* +* Flip around the FPU state too: +*/ + tmp = new_task->thread.i387; + new_task->thread.i387 = old_task->thread.i387; + old_task->thread.i387 = tmp; +}This is not going to work in this case (already posted twice in other emails):
i'm really sorry - i still have a huge email backlog.
Quoted 4 lines
So NTSK loads a non up2date FPUo, instead of the FPUc that was the "dirty" context to migrate (since
TS_USEDFPUwas set). I think you need an early__unlazy_fpu()in that case, that would turn the above into:
yes. My plan is to to avoid all these problems by having a special-purpose sched_yield_to(old_task, new_task) function.
this, besides being even faster than the default scheduler (because the runqueue balance does not change so no real scheduling decision has to be done - the true scheduling decisions happen later on at async-wakeup time), should also avoid all the FPU races: the FPU just gets flipped between old_task and new_task (and TS_USEDFPU needs to be moved as well, etc.). No intermediate task can come inbetween.
can you see a hole in this sched_yield_to() method as well?
Ingo
Re: [patch 08/13] syslets: x86, add move_user_context() method
Quoted 13 lines · Ingo Molnar
Quoted 10 lines · Davide Libenzi
Quoted 7 lines · Ingo Molnar
From: Ingo Molnar <[email protected]>
add the
move_user_context()method to move the user-space context of one kernel thread to another kernel thread. User-space might notice the changed TID, but execution, stack and register contents (general purpose and FPU) are still the same.
Quoted 6 lines
Quoted 3 lines
Also signal handling should/must be maintained, on top of TID. You don't want the user to be presented with a different signal handling after an
sys_async_execcall.right now
CLONE_SIGNALandCLONE_SIGHANDis used for new async threads, so they should inherit and share all the signal settings.
Right. Sorry I missed the signal cloning flags (still has to go thru the whole code).
Quoted 8 lines
Quoted 4 lines
So NTSK loads a non up2date FPUo, instead of the FPUc that was the "dirty" context to migrate (since
TS_USEDFPUwas set). I think you need an early__unlazy_fpu()in that case, that would turn the above into:yes. My plan is to to avoid all these problems by having a special-purpose
sched_yield_to(old_task, new_task)function.
Quoted 8 lines
this, besides being even faster than the default scheduler (because the runqueue balance does not change so no real scheduling decision has to be done - the true scheduling decisions happen later on at async-wakeup time), should also avoid all the FPU races: the FPU just gets flipped between
old_taskandnew_task(andTS_USEDFPUneeds to be moved as well, etc.). No intermediate task can come inbetween.can you see a hole in this
sched_yield_to()method as well?
Not sure till I see the code, but in that case we really need a sync©. This is really a fork-like for the FPU context IMO. The current "dirty" FPU context should follow both OTSK and NTSK.
- Davide
PATCH 9/13 syslets: x86, mark async unsafe syscalls
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
mark clone() and fork() as not available for async execution. Both need an intact user context beneath them to work.
--- arch/i386/kernel/ioport.c | 6 ++++++ arch/i386/kernel/ldt.c | 3 +++ arch/i386/kernel/process.c | 6 ++++++ arch/i386/kernel/vm86.c | 6 ++++++ 4 files changed, 21 insertions(+)
arch/i386/kernel/ioport.c +6 -0
@@ -62,6 +62,9 @@ asmlinkage long sys_ioperm(unsigned longstruct tss_struct * tss;unsigned long *bitmap; +if (async_syscall (current)) +return -ENOSYS ; +if ((from + num <= from) || (from + num >IO_BITMAP_BITS ))return -EINVAL ;if (turn_on && !capable (CAP_SYS_RAWIO ))
@@ -139,6 +142,9 @@ asmlinkage long sys_iopl(unsigned long uunsigned int old = (regs->eflags >>12 ) &3 ;struct thread_struct *t = ¤t->thread; +if (async_syscall (current)) +return -ENOSYS ; +if (level >3 )return -EINVAL ;/* Trying to gain more privileges? */
arch/i386/kernel/ldt.c +3 -0
@@ -233,6 +233,9 @@ asmlinkage int sys_modify_ldt(int func, {int ret = -ENOSYS ; +if (async_syscall (current)) +return -ENOSYS ; +switch (func) {case 0 : ret =read_ldt (ptr, bytecount);
arch/i386/kernel/process.c +6 -0
@@ -731,6 +731,9 @@ struct task_struct fastcall * __switch_t asmlinkage int sys_fork(struct pt_regs regs) { +if (async_syscall (current)) +return -ENOSYS ; +return do_fork (SIGCHLD , regs.esp, ®s,0 ,NULL ,NULL ); }
@@ -740,6 +743,9 @@ asmlinkage int sys_clone(struct pt_regsunsigned long newsp;int __user *parent_tidptr, *child_tidptr; +if (async_syscall (current)) +return -ENOSYS ; + clone_flags = regs.ebx; newsp = regs.ecx; parent_tidptr = (int __user *)regs.edx;
arch/i386/kernel/vm86.c +6 -0
@@ -208,6 +208,9 @@ asmlinkage int sys_vm86old(struct pt_regstruct task_struct *tsk;int tmp, ret = -EPERM ; +if (async_syscall (current)) +return -ENOSYS ; + tsk = current;if (tsk->thread.saved_esp0) goto out;
@@ -238,6 +241,9 @@ asmlinkage int sys_vm86(struct pt_regs rint tmp, ret;struct vm86plus_struct __user *v86; +if (async_syscall (current)) +return -ENOSYS ; + tsk = current;switch (regs.ebx) {case VM86_REQUEST_IRQ :
PATCH 10/13 syslets: x86: enable ASYNC_SUPPORT
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
enable CONFIG_ASYNC_SUPPORT on x86.
--- arch/i386/Kconfig | 4 ++++ 1 file changed, 4 insertions(+)
arch/i386/Kconfig +4 -0
@@ -38,6 +38,10 @@ config MMU bool default y +config ASYNC_SUPPORT + bool + default y + config SBUS bool
PATCH 11/13 syslets: x86, wire up the syslet system calls
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
wire up the new syslet / async system call syscalls and make it thus available to user-space.
--- arch/i386/kernel/syscall_table.S | 6 ++++++ include/asm-i386/unistd.h | 8 +++++++- 2 files changed, 13 insertions(+), 1 deletion(-)
arch/i386/kernel/syscall_table.S +6 -0
@@ -319,3 +319,9 @@ ENTRY(sys_call_table) .long sys_move_pages .long sys_getcpu .long sys_epoll_pwait + .long sys_async_exec /* 320 */ + .long sys_async_wait + .long sys_umem_add + .long sys_async_thread + .long sys_threadlet_on + .long sys_threadlet_off /* 325 */
include/asm-i386/unistd.h +7 -1
@@ -325,10 +325,16 @@#define __NR_move_pages 317#define __NR_getcpu 318#define __NR_epoll_pwait 319 +#define __NR_async_exec 320 +#define __NR_async_wait 321 +#define __NR_umem_add 322 +#define __NR_async_thread 323 +#define __NR_threadlet_on 324 +#define __NR_threadlet_off 325#ifdef __KERNEL__ -#define NR_syscalls 320 +#define NR_syscalls 326#define __ARCH_WANT_IPC_PARSE_VERSION#define __ARCH_WANT_OLD_READDIR
PATCH 12/13 syslets: x86: optimized copy_uatom()
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
provide an optimized assembly version of the copy_uatom() method. This is about 3 times faster than the C version.
--- arch/i386/lib/getuser.S | 115 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 115 insertions(+)
arch/i386/lib/getuser.S +115 -0
@@ -10,6 +10,121 @@ */ #include <asm/thread_info.h> +/* + * copy_uatom() - copy a syslet_atom from user-space into kernel-space: + */ + +.text +.align 4 +.globl copy_uatom +copy_uatom: + # + # regparm(2) call, %eax: atom, %edx: uatom + # + movl %eax, %ecx # %ecx is atom, %edx remains uatom + + cmpl $__PAGE_OFFSET-40, %edx # access_ok(uatom-sizeof(*uatom)) + jae bad_copy_uatom + + +1: movl (%edx), %eax # atom->flags = uatom->flags + movl %eax, (%ecx) + +2: movl 4(%edx), %eax # atom->nr = uatom->nr + movl %eax, 4(%ecx) + +3: movl 8(%edx), %eax # atom->ret_ptr = uatom->ret_ptr + movl %eax, 8(%ecx) + +4: movl 12(%edx), %eax # atom->next = uatom->next + movl %eax, 12(%ecx) + + +10: movl 16(%edx), %eax # atom->arg_ptr[0] = uatom->arg_ptr[0] + testl %eax, %eax + jz 20f # NULL ptr - zero out remaining args + cmpl $__PAGE_OFFSET, %eax # access_ok(arg_ptr) + jae bad_copy_uatom +100: movl (%eax), %eax + movl %eax, 16(%ecx) + +11: movl 20(%edx), %eax # atom->arg_ptr[1] = uatom->arg_ptr[1] + testl %eax, %eax + jz 21f # NULL ptr - zero out remaining args + cmpl $__PAGE_OFFSET, %eax # access_ok(arg_ptr) + jae bad_copy_uatom +110: movl (%eax), %eax + movl %eax, 20(%ecx) + +12: movl 24(%edx), %eax # atom->arg_ptr[2] = uatom->arg_ptr[2] + testl %eax, %eax + jz 22f # NULL ptr - zero out remaining args + cmpl $__PAGE_OFFSET, %eax # access_ok(arg_ptr) + jae bad_copy_uatom +120: movl (%eax), %eax + movl %eax, 24(%ecx) + +13: movl 28(%edx), %eax # atom->arg_ptr[3] = uatom->arg_ptr[3] + testl %eax, %eax + jz 23f # NULL ptr - zero out remaining args + cmpl $__PAGE_OFFSET, %eax # access_ok(arg_ptr) + jae bad_copy_uatom +130: movl (%eax), %eax + movl %eax, 28(%ecx) + +14: movl 32(%edx), %eax # atom->arg_ptr[4] = uatom->arg_ptr[4] + testl %eax, %eax + jz 24f # NULL ptr - zero out remaining args + cmpl $__PAGE_OFFSET, %eax # access_ok(arg_ptr) + jae bad_copy_uatom +140: movl (%eax), %eax + movl %eax, 32(%ecx) + +15: movl 36(%edx), %eax # atom->arg_ptr[5] = uatom->arg_ptr[5] + testl %eax, %eax + jz 25f # NULL ptr - zero out remaining args + cmpl $__PAGE_OFFSET, %eax # access_ok(arg_ptr) + jae bad_copy_uatom +150: movl (%eax), %eax + movl %eax, 36(%ecx) + + xorl %eax, %eax # return 0 + ret + + # + # Zero out arg values. Since ptr was NULL, %eax is zero: + # +20: movl %eax, 16(%ecx) # atom->args[0] = 0 +21: movl %eax, 20(%ecx) # atom->args[1] = 0 +22: movl %eax, 24(%ecx) # atom->args[2] = 0 +23: movl %eax, 28(%ecx) # atom->args[3] = 0 +24: movl %eax, 32(%ecx) # atom->args[4] = 0 +25: movl %eax, 36(%ecx) # atom->args[5] = 0 + + ret # return 0 + +bad_copy_uatom: + movl $-14, %eax + ret + +.section __ex_table,"a" + .long 1b, bad_copy_uatom + .long 2b, bad_copy_uatom + .long 3b, bad_copy_uatom + .long 4b, bad_copy_uatom + .long 10b, bad_copy_uatom + .long 100b, bad_copy_uatom + .long 11b, bad_copy_uatom + .long 110b, bad_copy_uatom + .long 12b, bad_copy_uatom + .long 120b, bad_copy_uatom + .long 13b, bad_copy_uatom + .long 130b, bad_copy_uatom + .long 14b, bad_copy_uatom + .long 140b, bad_copy_uatom + .long 15b, bad_copy_uatom + .long 150b, bad_copy_uatom +.previous /* * __get_user_X
PATCH 13/13 syslets: x86: optimized sys_umem_add()
In reply to Ingo MolnarFrom: Ingo Molnar <[email protected]>
provide an optimized assembly version of sys_umem_add(). It is about 2 times faster than the C version.
--- arch/i386/lib/getuser.S | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+)
arch/i386/lib/getuser.S +27 -0
@@ -11,6 +11,33 @@ #include <asm/thread_info.h> /* + * Optimized user-memory arithmetics system-call: + */ + +.text +.align 4 +.globl sys_umem_add +sys_umem_add: + movl 0x4(%esp), %ecx # uptr + movl 0x8(%esp), %edx # inc + + cmpl $__PAGE_OFFSET, %ecx # access_ok(uptr) + jae bad_sys_umem_add + +1: addl %edx, (%ecx) # *uptr += inc +2: movl (%ecx), %eax # return *uptr + ret + +bad_sys_umem_add: + movl $-14, %eax + ret + +.section __ex_table,"a" + .long 1b, bad_sys_umem_add + .long 2b, bad_sys_umem_add +.previous + +/* * copy_uatom() - copy a syslet_atom from user-space into kernel-space: */
Quoted 2 lines · Ingo Molnar
I believe this threadlet concept is what user-space will want to use for programmable parallelism.
This is brilliant. Now it needs just four more things:
1) Documentation of what you can and can't do safely from a threadlet, given that it runs in an unknown thread context;
2) Facilities for manipulating pools of threadlets, so you can throttle their concurrency, reprioritize them, and cancel them in bulk, disposing safely of any dynamically allocated memory, synchronization primitives, and so forth that they may be holding;
3) Reworked threadlet scheduling to allow tens of thousands of blocked threadlets to be dispatched efficiently in a controlled, throttled, non-cache-and-MMU-thrashing manner, immediately following the softirq that unblocks the I/O they're waiting on; and
4) AIO vsyscalls whose semantics resemble those of IEEE 754 floating point operations, with a clear distinction between a) pipeline state vs. operands, b) results vs. side effects, and c) coding errors vs. not-a-number results vs. exceptions that cost you a pipeline flush and nonlocal branch.
When these four problems are solved (and possibly one or two more that I'm not thinking of), you will have caught up with the state of the art in massively parallel event-driven cooperative multitasking frameworks. This would be a really, really good thing for Linux and its users.
Cheers,
- Michael
Quoted 4 lines · Michael K. Edwards
3) Reworked threadlet scheduling to allow tens of thousands of blocked threadlets to be dispatched efficiently in a controlled, throttled, non-cache-and-MMU-thrashing manner, immediately following the softirq that unblocks the I/O they're waiting on; and
threadlets, when they dont block, are just regular user-space function calls - so no need to schedule or throttle them. [*]
threadlets, when they block, are regular kernel threads, so the regular O(1) scheduler takes care of them. If MMU trashing is of any concern then syslets should be used to implement the most performance-critical
events: under Linux a kernel thread that does not exit out to user-space does not do any TLB switching at all. (even if there are multiple processes active and their syslets intermix)
throttling of outstanding async contexts is most easily done by user-space - you can see an example in threadlet-test.c, but there's also fio/engines/syslet-rw.c. v2 had a kernel-space throttling mechanism as well, i'll probably reintroduce that in later versions.
Ingo
[*] although certain more advanced scheduling tactics like the detection
of frequently executed threadlet functions and their pushing out to separate contexts is possible too - but this is an optional add-on and for later.
Quoted 2 lines · Ingo Molnar
threadlets, when they dont block, are just regular user-space function calls - so no need to schedule or throttle them. [*]
Right. That's a great design feature.
Quoted 6 lines
threadlets, when they block, are regular kernel threads, so the regular O(1) scheduler takes care of them. If MMU trashing is of any concern then syslets should be used to implement the most performance-critical
events: under Linux a kernel thread that does not exit out to user-space does not do any TLB switching at all. (even if there are multiple processes active and their syslets intermix)
As far as I am concerned syslets by themselves are a dead letter, because you can't do any of the things that potential application coders need to do with them. As for threadlets, making them kernel threads is not such a good design feature, O(1) scheduler or not. You take the full hit of kernel task creation, on the spot, for every threadlet that blocks. You don't fence off the threadlet from any of the stuff that it ought to be fenced off from for thread-safety reasons, so you don't have much choice but to create a new TLS arena for it (which you need anyway for errno), so they have horrible MMU and memory overhead. You can't dispatch them inexpensively, while the data delivered by a softirq is still hot in cache, to traverse 1-3 lines of userspace code and make the next syscall. So they're just not usable for any of the things that a real AIO application actually does.
Quoted 4 lines
throttling of outstanding async contexts is most easily done by user-space - you can see an example in
threadlet-test.c, but there's alsofio/engines/syslet-rw.c. v2 had a kernel-space throttling mechanism as well, i'll probably reintroduce that in later versions.
You're telling me that scheduling parallel I/O is the kernel's job but throttling it is userspace's job?
Quoted 4 lines
[*] although certain more advanced scheduling tactics like the detection
of frequently executed threadlet functions and their pushing out to separate contexts is possible too - but this is an optional add-on and for later.
You won't be able to do it later if you don't design for it now. Don't reinvent the square wheel -- there's a model to follow that was so successful that it has killed all alternate models in its sphere. Namely, IEEE 754. But please try not to make pipeline flushes suck as much as they did on the i860.
Cheers,
- Michael
Quoted 5 lines · Michael K. Edwards
You won't be able to do it later if you don't design for it now. Don't reinvent the square wheel -- there's a model to follow that was so successful that it has killed all alternate models in its sphere. Namely, IEEE 754. But please try not to make pipeline flushes suck as much as they did on the i860.
To understand why I harp on IEEE 754 as a sane model for pipelined AIO, you might consider reading (at least parts of):
http://www.cs.berkeley.edu/~wkahan/JAVAhurt.pdf
People who write industrial-strength floating point programs rely on the IEEE floating point semantics to avoid having to check every result of every arithmetic step to see whether it is a valid input to the next step. NaNs and +/-0 and overflows and all that jazz are essential to efficient coding of things like matrix inversion, because the only alternative is simply to fail. But in-line indications of an exceptional result aren't enough, because it may or may not have been a coding error, and you may need fine-grained control over which "failure conditions" are within the realm of the expected and which are not.
Here's a quotable bit from Kahan and Darcy's polemic:
<quote>
To achieve Floating-Point Predictability:
Limit programmers' choices to what is reasonable and necessary as
well as parsimonious, and
Limit language implementors'choices so as always to honor the
programmer's choices.
To do so, language designers must understand floating-point well enough to validate their determination of "what is reasonable and necessary," or else must entrust that determination to someone else with the necessary competency.
</quote>
Now I ain't that "someone else", when it comes to AIO pipelining. But they're out there. Figure out how to create an AIO model that honors the RDBMS programmer's choices efficiently on a NUMA box without making him understand NUMA, and you really will have created something for the ages.
Cheers,
- Michael
Quoted 4 lines · Michael K. Edwards
[...] As for threadlets, making them kernel threads is not such a good design feature, O(1) scheduler or not. You take the full hit of kernel task creation, on the spot, for every threadlet that blocks. [...]
this is very much not how they work. Threadlets share the same basic infrastructure with syslets and they do /not/ take a 'full hit of kernel thread creation' when they block. Please read the announcements, past discussions on lkml and the code about how it works.
about your other point:
Quoted 11 lines
Quoted 7 lines
threadlets, when they block, are regular kernel threads, so the regular O(1) scheduler takes care of them. If MMU trashing is of any concern then syslets should be used to implement the most performance-critical events: under Linux a kernel thread that does not exit out to user-space does not do any TLB switching at all. (even if there are multiple processes active and their syslets intermix)
As far as I am concerned syslets by themselves are a dead letter, because you can't do any of the things that potential application coders need to do with them. [...]
syslets are not meant to be directly exposed to application coders. Syslets (like many of my previous mails stated) are meant as building blocks to higher-level AIO interfaces such as in glibc or libaio. Then user-space can build its state-machine based on syslet-implemented glibc/libaio. In that specific role they are a very fast and scalable mechanism.
Ingo
Quoted 9 lines · Ingo Molnar
Quoted 4 lines
[...] As for threadlets, making them kernel threads is not such a good design feature, O(1) scheduler or not. You take the full hit of kernel task creation, on the spot, for every threadlet that blocks. [...]
this is very much not how they work. Threadlets share the same basic infrastructure with syslets and they do /not/ take a 'full hit of kernel thread creation' when they block. Please read the announcements, past discussions on lkml and the code about how it works.
Sorry, you're right, I jumped to a conclusion here without reading the implementation. I read too much into your statement that "threadlets, when they block, are regular kernel threads". So tell me, at what stage is NPTL going to need a new TLS context for errno and all that? Immediately when the threadlet first blocks, right? At most you can delay the bulk page copies with CoW MMU tricks (about which I cannot begin to match your knowledge). But you can't let any code run that might touch errno -- or FPU state or anything else you need to preserve for when you do carry on with the threadlet -- until you've at least told the hardware to fault on write.
Yes, I will go back and read the code for myself. This will take me some time because I have only a hand-waving level of knowledge about task_structs and pt_regs, and have largely avoided the dark corners of the x86 architecture. But I think my point still stands: allowing code inside threadlets to use the usual C library wrappers around the usual synchronous syscalls is going to mean that the threadlet context is fairly heavyweight, both in memory and CPU/MMU state. This means that you can't pull it cheaply over to whatever CPU core happened to process the device I/O that delivered the data it wanted.
If the cost of threadlet migration isn't negligible, then you can't just write code that initiates a zillion threadlets in a loop -- not if you want to be able to exploit NUMA or even SMP efficiently. You have to distribute the threadlet initiation among parallel threads on all the CPUs -- at which point you are back where you started, with the application explicitly partitioned among CPU-locked dispatch threads. Any programming team prepared to cope with that is probably going to stick to the userspace state machine they probably already have for managing delayed I/O responses.
Quoted 6 lines
syslets are not meant to be directly exposed to application coders. Syslets (like many of my previous mails stated) are meant as building blocks to higher-level AIO interfaces such as in glibc or libaio. Then user-space can build its state-machine based on syslet-implemented glibc/libaio. In that specific role they are a very fast and scalable mechanism.
With all due respect -- and I know how successful you have been with major new kernel features in the past -- I think that's a cop-out. That's like saying that floating point is not meant to be directly exposed to application coders. Sure, the details of the floating point _pipeline_ are essentially opaque; but I don't have to package up a string of floating point operations into a "floatlet" and send it off to the FPU. From the point of view of the integer unit, I move things into and out of floating point registers, and in between I issue instructions to the FPU to do arithmetic on its registers. If something goes mildly wrong (say, underflow), and I've told the FPU to carry on under those circumstances, it does. If something goes bad wrong, or if underflow happens and I've told the FPU that my code won't do the right thing on underflow, I get an exception. That's it.
If the FPU decides to pipeline things, that's not my problem; when I get to the operation that wants to pull a result back over to the integer unit, I stall until it's ready. And in a cleverer, more tightly interlocked processor that issues some things in parallel and speculatively executes others, exceptions may not be deliverable until long after the arithmetic op that produced them (you might not wind up taking that branch). Hence other state may have to be rewound so that the exception is delivered with everything else in the state it would have been in if the processor weren't so damn clever.
You don't have to invent all that pipelining and migration and speculative execution stuff up front for AIO. But if you don't stick to what is "reasonable and necessary as well as parsimonious" when defining what's allowed inside a threadlet, you won't leave implementations any future flexibility. And "want speed? use syslets instead" is no answer, especially if you tell me that syslets wrapped in glibc are only really useful for short-circuiting chained states in a state machine. I. Don't. Want. To. Write. State. Machines. Any. More.
Cheers,
- Michael
Oh, and while I haven't written a kernel or an RDBMS, I have written some fairly serious non-blocking I/O code (without resorting to threads; one socket and thousands of independent userspace state machines) and rewritten the plumbing of two fairly heavy-duty network operations frameworks, one of them attached to a horrifically complex GUI. And briefly, long ago, I made Transputers dance with Occam and galaxies spin with PVM. This gives me exactly zero credentials here, of course, but may suggest to you that when I say something that seems naive, it's more likely that I got the Linux-specific lingo wrong. That, or I'm _actively_ stupid. :-)
x86 hardware and transputers (Re: [patch 00/13] Syslets, "Threadlets", generic AIO support, v3)
Quoted 4 lines
From: "Michael K. Edwards"
Newsgroups: gmane.linux.kernel
Subject: Re: [patch 00/13] Syslets, "Threadlets", generic AIO support, v3
Date: Thu, 22 Feb 2007 00:59:10 -0800
[striping cc list]
[]
Quoted 10 lines · Ingo Molnar
Quoted 9 lines
Quoted 4 lines
[...] As for threadlets, making them kernel threads is not such a good design feature, O(1) scheduler or not. You take the full hit of kernel task creation, on the spot, for every threadlet that blocks. [...]
this is very much not how they work. Threadlets share the same basic infrastructure with syslets and they do /not/ take a 'full hit of kernel thread creation' when they block. Please read the announcements, past discussions on lkml and the code about how it works.
[]
Quoted 4 lines
Yes, I will go back and read the code for myself. This will take me some time because I have only a hand-waving level of knowledge about
task_structsandpt_regs, and have largely avoided the dark corners of the x86 architecture.
This architecture was brought to us by windows on our screens. And it took years (a decade?) for them to use all hardware features:
(IA-32, i386) --> (MS Windows NT,9X)
Yet you must still do much system programming to use that features.
While
Quoted 6 lines
But I think my point still stands: allowing code inside threadlets to use the usual C library wrappers around the usual synchronous syscalls is going to mean that the threadlet context is fairly heavyweight, both in memory and CPU/MMU state. This means that you can't pull it cheaply over to whatever CPU core happened to process the device I/O that delivered the data it wanted.
[]
Quoted 7 lines
Oh, and while I haven't written a kernel or an RDBMS, I have written some fairly serious non-blocking I/O code (without resorting to threads; one socket and thousands of independent userspace state machines) and rewritten the plumbing of two fairly heavy-duty network operations frameworks, one of them attached to a horrifically complex GUI. And briefly, long ago, I made Transputers dance with Occam and galaxies spin with PVM.
transputers were (AFAIK) completely orthogonal to any today's x86 CPU architecture -- hardware parallelism, special programming language and technique to match this hardware. And they were chosen to work on Mars in mid-90th, while crowd wanted more stupid windows on cheap CPUs.
Quoted 4 lines
This gives me exactly zero credentials here, of course, but may suggest to you that when I say something that seems naive, it's more likely that I got the Linux-specific lingo wrong. That, or I'm _actively_ stupid. :-)
Thus, i think, you are thinking mostly on hardware level, while it's longstanding software problem, i.e. to use x86 (:.
Regards.
--
-o--=O`C
#oo'L O
<___=E M
Re: x86 hardware and transputers (Re: [patch 00/13] Syslets, "Threadlets", generic AIO support, v3)
Quoted 11 lines · Oleg Verych
Quoted 4 lines
Yes, I will go back and read the code for myself. This will take me some time because I have only a hand-waving level of knowledge about
task_structsandpt_regs, and have largely avoided the dark corners of the x86 architecture.This architecture was brought to us by windows on our screens. And it took years (a decade?) for them to use all hardware features:
(IA-32, i386) --> (MS Windows NT,9X)Yet you must still do much system programming to use that features.
Actually, this architecture was brought to us largely by WordPerfect, VisiCalc, and IEEE754. Nobody really cares what bloody operating system the thing is running; they cared then, and care now, about being able to write reports and memos that print cleanly and to build spreadsheets that calculate correctly. Both of these things are made much more practical by predictable floating point semantics, which meant at first that you had to write your own floating point library. The first (and for a long time the only) piece of hardware to put _usable_ hardware floating point within reach of the desktop was the Intel 80387. Usable, not because it was more accurate than the soft version (it wasn't, actually quite the reverse), but because it got the exception semantics right.
The '387 is what made the PC architecture the _only_ choice for the corporate desktop, pretty much immediately upon its release in 1987. My first corporate job was porting an electric utility's in-house revenue requirements application -- written in Fortran with assembly display routines -- from a Prime mini to the PC. I still have the nice leather coffee coaster with the Prime logo on my desk. The rest of Prime is dead and forgotten, largely because of the '387.
Quoted 4 lines
transputers were (AFAIK) completely orthogonal to any today's x86 CPU architecture -- hardware parallelism, special programming language and technique to match this hardware. And they were chosen to work on Mars in mid-90th, while crowd wanted more stupid windows on cheap CPUs.
Y'know, what goes around comes around. The HyperTransport CPU interconnect from AMD that all the overclocker types are so excited about is just the Transputer ports warmed over, with a modern cache coherency protocol stacked on top. Worked on one of those too, on the Intel HyperCube -- it's not my fault that the i860 (predecessor of the Itanic, in a way) lost its marbles so comprehensively on IRQ that you couldn't do anything I/O intensive with it.
My first government job (at NASA) started with a crash course in Occam and explicit parallelism, but it was so blindingly obvious that this had no future outside its little niche that I looked around for other stuff to do. The adjacent console belonged to a Symbolics LISP machine -- also clearly a box with no future, since the only applications for it that still mattered (expert systems) were in the last stages of being ported to a C-based expert system engine developed down the hall (which is now open source, and which I have had occasion to use for many purposes since). I was a Mac weenie at the time, so I polished my C skills working on the Mac port of CLIPS and writing a genetic algorithm engine. Had I stuck to the Transputer, I would probably know a lot more about faking NUMA using a cache coherency protocol than I do today.
Quoted 2 lines
Thus, i think, you are thinking mostly on hardware level, while it's longstanding software problem, i.e. to use x86 (:.
I don't think much about hardware or software. I think about shipping products in volume at positive gross margin, even when what's coming out of my fingertips is source code and shell commands. That's why I've worked mostly on widgets with ARMs inside in recent years. But I'm kinda bored with that, and Niagara or Octeon may wind up cheap in volume if somebody with extra fab capacity scoops up the wreckage of Sun or Cavium, so I'm here harassing people more competent than I about what it takes to make them programmable by mere mortals.
Cheers,
- Michael
Quoted 2 lines · Michael K. Edwards
1) Documentation of what you can and can't do safely from a threadlet, given that it runs in an unknown thread context;
you can do just about anything from a threadlet, using bog standard procedural programming. (Certain system-calls are excluded at the moment out of caution - but i'll probably lift restrictions like sys_clone() use because sys_clone() can be done safely from a threadlet.)
The code must be thread-safe, because the kernel can move execution to a new thread anytime and then it will execute in parallel with the main thread. There's no other requirement.
Wrt. performance, one good model is to run request-alike functionality from a threadlet, to maximize parallelism.
ingo
Quoted 4 lines · Michael K. Edwards
2) Facilities for manipulating pools of threadlets, so you can throttle their concurrency, reprioritize them, and cancel them in bulk, disposing safely of any dynamically allocated memory, synchronization primitives, and so forth that they may be holding;
pthread_cancel() [if/once threadlets are integrated into pthreads] ought to do that. A threadlet, if it gets moved to an async context, is a full-blown thread.
Ingo
Quoted 3 lines · Ingo Molnar
pthread_cancel()[if/once threadlets are integrated into pthreads] ought to do that. A threadlet, if it gets moved to an async context, is a full-blown thread.
The fact that you are proposing pthread_cancel as a model for how to abort an unfinished threadlet suggests -- to me, and I would think to anyone who has ever written code that had no choice but to call pthread_cancel -- that you have not thought about this part of the problem.
Cheers,
- Michael
Quoted 5 lines · Michael K. Edwards
4) AIO vsyscalls whose semantics resemble those of IEEE 754 floating point operations, with a clear distinction between a) pipeline state vs. operands, b) results vs. side effects, and c) coding errors vs. not-a-number results vs. exceptions that cost you a pipeline flush and nonlocal branch.
threadlets (and syslets) are parallel contexts and they behave so - queuing and execution semantics are then ontop of that, implemented either by glibc, or implemented by the application. There is no 'pipeline' of requests imposed - the structure of pending requests is totally free-form. For example in threadlet-test.c i've in essence implemented a 'set of requests' with the submission site only interested in whether all requests are done or not - but any stricter (or even looser) semantics and ordering can be used too.
in terms of AIO, the best queueing model is i think what the kernel uses
internally: freely ordered, with barrier support. (That is equivalent to a "queue of sets", where the queue are the barriers, and the sets are the requests within barriers. If there is no barrier pending then there's just one large freely-ordered set of requests.)
Ingo
Quoted 2 lines · Ingo Molnar
in terms of AIO, the best queueing model is i think what the kernel uses
internally: freely ordered, with barrier support.
Speaking of AIO, how do you imagine lio_listio is implemented? If there is no asynchronous syscall it would mean creating a threadlet for each request but this means either waiting or creating several/many threads.
Signature · 1 line
➧ Ulrich Drepper ➧ Red Hat, Inc. ➧ 444 Castro St ➧ Mountain View, CA ❖
Quoted 8 lines · Ulrich Drepper
Quoted 2 lines · Ingo Molnar
in terms of AIO, the best queueing model is i think what the kernel uses
internally: freely ordered, with barrier support.Speaking of AIO, how do you imagine
lio_listiois implemented? If there is no asynchronous syscall it would mean creating a threadlet for each request but this means either waiting or creating several/many threads.
my current thinking is that special-purpose (non-programmable, static) APIs like aio_*() and lio_*(), where every last cycle of performance matters, should be implemented using syslets - even if it is quite tricky to write syslets (which they no doubt are - just compare the size of syslet-test.c to threadlet-test.c). So i'd move syslets into the same category as raw syscalls: pieces of the raw infrastructure between the kernel and glibc, not an exposed API to apps. [and even if we keep them in that category they still need quite a bit of API work, to clean up the 32/64-bit issues, etc.]
The size of the async thread pool can be kept in check either from user-space (by starting to queue up requests after a certain point of saturation without submitting them) or from kernel-space which involves waiting (the latter was present in v2 but i temporarily removed it from v3). "You have to wait" is the eventual final answer in every well-behaved queueing system anyway.
How things work out with a large number of outstanding threads in real apps is still an open question (until someone tries it) but i'm cautiously optimistic: in my own (FIO based) measurements syslets beat the native KAIO interfaces both in the cached and in the non-cached [== many threads] case. I did not expect the latter at all: the non-cached syslet codepath is not optimized at all yet, so i expected it to have (much) higher CPU overhead than KAIO.
This means that KAIO is in worse shape than i thought - there's just way too much context KAIO has to build up to submit parallel IO contexts. Many years of optimizations went into KAIO already, so it's probably at its outer edge of performance capabilities. Furthermore, what KAIO has to compete against in the syslet case are the synchronous syscalls turned async, and more than a decade of optimizations went into all the synchronous syscalls. Plus the 'threading overhead of syslets' really boils down to 'scheduling overhead' in the end - and we can do over a million context-switches a second, per CPU. What killed user-space thread-based AIO performance many moons ago wasnt really the threading concept itself or scheduling overhead, it was the (then) fragile threading implementation of Linux, combined with the resulting signal-based AIO code. Catching and handling a single signal is more expensive than a context-switch - and signals have legacies attached to them that make them hard to scale within the kernel. Plus with syslets the 'threading overhead' is optional, it only happens when it has to.
Plus there's the fundamental killer that KAIO is a /lot/ harder to implement (and to maintain) on the kernel side: it has to be implemented for every IO discipline, and even for the IO disciplines it supports at the moment, it is not truly asynchronous for things like metadata blocking or VFS blocking. To handle things like metadata blocking it has to resort to non-statemachine techniques like retries - which are bad for performance.
Syslets/threadlets on the other hand, once the core is implemented, have near zero ongoing maintainance cost (compared to KAIO pushed into every IO subsystem) and cover all IO disciplines and API variants immediately, and they are as perfectly asynchronous as it gets.
So all in one, i used to think that AIO state-machines have a long-term place within the kernel, but with syslets i think i've proven myself embarrasingly wrong =B-)
Ingo
Hi Ingo, developers.
Quoted 8 lines · Ingo Molnar
Syslets/threadlets on the other hand, once the core is implemented, have near zero ongoing maintainance cost (compared to KAIO pushed into every IO subsystem) and cover all IO disciplines and API variants immediately, and they are as perfectly asynchronous as it gets.
So all in one, i used to think that AIO state-machines have a long-term place within the kernel, but with syslets i think i've proven myself embarrasingly wrong =B-)
Hmm...
Try to have a network web server with huge load made on top of syslets/threadlets.
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by tcp_sendmsg() for slow clients - rescheduling will kill a machine.
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in tcp_sendmsg() over gigabit lan between quite fast machines.
Or threadlet/syslet AIO should not be used with networking too?
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 4 lines
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by
tcp_sendmsg()for slow clients - rescheduling will kill a machine.
I think it's time to make a split in what "context switch" or "reschedule" means...
there are two types of context switch:
1) To a different process. This means teardown of the TLB, going to a new MMU state, saving FPU state etc etc etc. This is obviously quite expensive
2) To a thread of the same process. No TLB flush no new MMU state, effectively all it does is getting a new task struct on the kernel side, and a new ESP/EIP pair on the userspace side. If there is FPU code involved that gets saved as well.
Number 1 is very expensive and that is what is really worrying normally; number 2 is a LOT lighter weight, and while Linux is a bit heavy there, it can be made lighter... there's no fundamental reason for it to be really expensive.
Signature · 2 lines
if you want to mail me at work (you don't), use arjan (at) linux.intel.com Test the interaction between Linux and your BIOS via http://www.linuxfirmwarekit.org
Quoted 19 lines · Arjan van de Ven
Quoted 4 lines
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by
tcp_sendmsg()for slow clients - rescheduling will kill a machine.I think it's time to make a split in what "context switch" or "reschedule" means...
there are two types of context switch:
1) To a different process. This means teardown of the TLB, going to a new MMU state, saving FPU state etc etc etc. This is obviously quite expensive
2) To a thread of the same process. No TLB flush no new MMU state, effectively all it does is getting a new task struct on the kernel side, and a new ESP/EIP pair on the userspace side. If there is FPU code involved that gets saved as well.
Quoted 4 lines
Number 1 is very expensive and that is what is really worrying normally; number 2 is a LOT lighter weight, and while Linux is a bit heavy there, it can be made lighter... there's no fundamental reason for it to be really expensive.
It does not matter - even with threads cost of having thousands of threads is _too_ expensive. So, IMO, it is wrong to have to create 20k threads for the simple web server which only sends one index page to 80k connections with 4k connections per seconds rate.
Just have that example in mind - more than 20k blocks in 80k connections over gigabit lan, and it is likely optimistic result, when designing new type of AIO.
Quoted 3 lines
Signature · 2 lines
if you want to mail me at work (you don't), use arjan (at) linux.intel.com Test the interaction between Linux and your BIOS via http://www.linuxfirmwarekit.org
Signature · 1 line
Evgeniy Polyakov
From: Evgeniy Polyakov <[email protected]>
Date: Thu, 22 Feb 2007 15:39:30 +0300
Quoted 8 lines
It does not matter - even with threads cost of having thousands of threads is _too_ expensive. So, IMO, it is wrong to have to create 20k threads for the simple web server which only sends one index page to 80k connections with 4k connections per seconds rate.
Just have that example in mind - more than 20k blocks in 80k connections over gigabit lan, and it is likely optimistic result, when designing new type of AIO.
I totally agree with Evgeniy on these points.
Using things like syslets and threadlets for networking I/O is not a very good idea. Blocking is more the norm than the exception for networking I/O.
Quoted 6 lines · David Miller
If used for networking one could easily make this new interface create an arbitrary number of threads by just opening up that many connections to such a server and just sitting there not reading anything from any of the client sockets. And this happens non-maliciously for slow clients, whether that is due to application blockage or the characteristics of the network path.
there are two issues on which i'd like to disagree.
Firstly, i dont think you are fully applying the syslet/threadlet model. There is no reason why an 'idle' client would have to use up a full thread! It all depends on how you use syslets/threadlets, and how (frequently) you queue back requests from cachemiss threads back to the primary thread. It is only the simplest queueing model where there is one thread per request that is currently blocked. Syslets/threadlets do /not/ force request processing to be performed in the async context forever - the async thread could very much queue it back to the primary context. (That's in essence what Tux did.) So the same state-machine techniques can be applied on both the syslet and the threadlet model, but in much more natural (and thus lower overhead) points: /between/ system calls and not in the middle of them. There are a number of measures that can be used to keep the number of parallel threads down.
Secondly, even assuming lots of pending requests/async-threads and a naive queueing model, an open request will eat up resources on the server no matter what. So if your point is that "+4K of kernel stack pinned down per open, blocked request makes syslets and threadlets not a very good idea", then i'd like to disagree with that: while it wont be zero-cost (4K does cost you 400MB of RAM per 100,000 outstanding threads), it's often comparable to the other RAM costs that are already attached to an open connection.
(let me know if i misunderstood your point.)
Ingo
From: Ingo Molnar <[email protected]>
Date: Thu, 22 Feb 2007 15:31:45 +0100
Quoted 5 lines
Firstly, i dont think you are fully applying the syslet/threadlet model. There is no reason why an 'idle' client would have to use up a full thread! It all depends on how you use syslets/threadlets, and how (frequently) you queue back requests from cachemiss threads back to the primary thread. It is only the simplest queueing model where there is
Quoted 8 lines
one thread per request that is currently blocked. Syslets/threadlets do /not/ force request processing to be performed in the async context forever - the async thread could very much queue it back to the primary context. (That's in essence what Tux did.) So the same state-machine techniques can be applied on both the syslet and the threadlet model, but in much more natural (and thus lower overhead) points: /between/ system calls and not in the middle of them. There are a number of measures that can be used to keep the number of parallel threads down.
Ok.
Quoted 8 lines
Secondly, even assuming lots of pending requests/async-threads and a naive queueing model, an open request will eat up resources on the server no matter what. So if your point is that "+4K of kernel stack pinned down per open, blocked request makes syslets and threadlets not a very good idea", then i'd like to disagree with that: while it wont be zero-cost (4K does cost you 400MB of RAM per 100,000 outstanding threads), it's often comparable to the other RAM costs that are already attached to an open connection.
The 400MB is extra, and it's in no way commensurate with the cost of the TCP socket itself even including the application specific state being used for that connection.
Even if it would be _equal_, we would be doubling the memory requirements for such a scenerio.
This is why I dislike the threadlet model, when used in that way.
The pushback to the primary thread you speak of is just extra work in my mind, for networking. Better to just begin operations and sit in the primary thread(s) waiting for events, and when they arrive push the operations further along using non-blocking writes, reads, and accept() calls. There is no blocking context really needed for these kinds of things, so a mechanism that tries to provide one is a waste.
As a side note although Evgeniy likes M:N threading model ideas, they are a mine field wrt. signal semantics. Solaris guys took several years to get it right, just grep through the Solaris kernel patch readme files over the years to get an idea of how bad it can be. I would therefore never advocate such an approach.
The more I think about it, a reasonable solution might actually be to use threadlets for disk I/O and pure event based processing for networking. It is two different handling paths and non-unified, but that might be the price for good performance :-)
Quoted 5 lines · David Miller
As a side note although Evgeniy likes M:N threading model ideas, they are a mine field wrt. signal semantics. Solaris guys took several years to get it right, just grep through the Solaris kernel patch readme files over the years to get an idea of how bad it can be. I would therefore never advocate such an approach.
I have fully synchronous kevent signal delivery for that purpose :) Having all events synchronous allows trivial handling of them - including signals.
Quoted 4 lines
The more I think about it, a reasonable solution might actually be to use threadlets for disk I/O and pure event based processing for networking. It is two different handling paths and non-unified, but that might be the price for good performance :-)
Hmm, yes, for such scenario we need some kind of event delivery mechanism, which would allow to wait on different kinds of events.
In the above sentence I see known to pain letters - letter k
letter e
letter v
letter e
letter n
letter t
Or more modern trend - async_wait(epoll).
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · David Miller
The pushback to the primary thread you speak of is just extra work in my mind, for networking. Better to just begin operations and sit in the primary thread(s) waiting for events, and when they arrive push the operations further along using non-blocking writes, reads, and
accept()calls. There is no blocking context really needed for these kinds of things, so a mechanism that tries to provide one is a waste.
one question is, what is cheaper, to block out of a read and a write and to set up the event notification and then to return to the user context, or to just stay right in there with all the context already constructed and on the stack, and schedule away and then come back and queue back to the primary thread once the condition the thread is waiting for is done? The latter isnt all that unattractive in my mind, because it always does forward progress, with minimal 'backout' costs.
furthermore, in a real webserver there's a whole lot of other stuff happening too: VFS blocking, mutex/lock blocking, memory pressure blocking, filesystem blocking, etc., etc. Threadlets/syslets cover them /all/ and never hold up the primary context: as long as there's more requests to process, they will be processed. Plus other important networked workloads, like fileservers are typically on fast LANs and those requests are very much a fire-and-forget matter most of the time.
in any case, this definitely needs to be measured.
Ingo
Quoted 9 lines · Ingo Molnar
Quoted 7 lines
The pushback to the primary thread you speak of is just extra work in my mind, for networking. Better to just begin operations and sit in the primary thread(s) waiting for events, and when they arrive push the operations further along using non-blocking writes, reads, and
accept()calls. There is no blocking context really needed for these kinds of things, so a mechanism that tries to provide one is a waste.one question is, what is cheaper, to block out of a read and a write and
^-------to back out
Quoted 6 lines
to set up the event notification and then to return to the user context, or to just stay right in there with all the context already constructed and on the stack, and schedule away and then come back and queue back to the primary thread once the condition the thread is waiting for is done? The latter isnt all that unattractive in my mind, because it always does forward progress, with minimal 'backout' costs.
Ingo
From: Ingo Molnar <[email protected]>
Date: Thu, 22 Feb 2007 16:15:09 +0100
Quoted 7 lines
furthermore, in a real webserver there's a whole lot of other stuff happening too: VFS blocking, mutex/lock blocking, memory pressure blocking, filesystem blocking, etc., etc. Threadlets/syslets cover them /all/ and never hold up the primary context: as long as there's more requests to process, they will be processed. Plus other important networked workloads, like fileservers are typically on fast LANs and those requests are very much a fire-and-forget matter most of the time.
I expect clients of a fileserver to cause the server to block in places such as tcp_sendmsg() as much if not more so than a webserver :-)
But yes, it should all be tested, for sure.
Quoted 9 lines · David Miller
Quoted 8 lines
furthermore, in a real webserver there's a whole lot of other stuff happening too: VFS blocking, mutex/lock blocking, memory pressure blocking, filesystem blocking, etc., etc. Threadlets/syslets cover them /all/ and never hold up the primary context: as long as there's more requests to process, they will be processed. Plus other important networked workloads, like fileservers are typically on fast LANs and those requests are very much a fire-and-forget matter most of the time.
Quoted 3 lines
I expect clients of a fileserver to cause the server to block in places such as
tcp_sendmsg()as much if not more so than a webserver :-)
yeah, true. But ... i'd still like to midly disagree with the characterisation that due to blocking being the norm in networking, that this goes against the concept of syslets/threadlets.
Networking has a 'work cache' too, in an abstract sense, which works in favor of syslets: the socket buffers. If there is a reasonably sized output queue for sockets (not extremely small like 4k per socket but something at least 16k), then user-space can chunk up its workload along pretty reasonable lines without assuming too much, and turn one such 'chunk' into one atomic step done in the 'syslet/threadlet request'. In the rare cases where blocking happens in an unexpected way, the syslet/threadlet 'goes async' but that only holds up that particular request, and only for that chunk, not the main loop of processing and doesnt force the request into an async thread forever.
the kevent model is very much about: /never every/ block the main thread. If you ever block, performance goes down the drain.
the syslet performance model is: if you block less than say 10-20% of the time, you are basically as fast as the most extreme kevents based model. Syslets/threadlets also avoids the fundamental workflow problem that nonblocking designs have in a natural way: 'how do we guarantee that the system progresses forward', which problem makes nonblocking code quite fragile.
another property is that the performance curve is alot less sensitive to blocking in the syslet model - and real user-space servers will always have unexpected points of blockage - unless all of userspace code is perfectly converted into state machines - which is not reasonable. So with syslets we are not forced to program everything as state-machines in user-space, such techniques are only needed to reduce the amount of context-switching and to reduce the RAM footprint - they wont change fundamental scalability.
plus there's the hidden advantage of having a 'constructed state' on the kernel stack: thread that blocks in the middle of tcp_sendmsg() has quite some state: the socket has been looked up in the hash(es), all input parameters have been validated, the timer has been set, skbs have been allocated ahead, etc. Those things do add up especially if you are after a long wait and all those things are scattered around the memory map cache-cold - not nicely composed into a single block of memory on the stack (generating only a single cachemiss in essence).
All in one, i'm cautiosly optimistic that even a totally naive, blocks-itself-for-every-request syslet application would perform pretty close to a Tux/kevents type of nonblock+event-queueing based application
- with a vastly higher generic utility benefit. So i'm not dismissing this possibility and i'm not writing off syslet performance just because they do context-switches :-)
Ingo
Quoted 4 lines · David Miller
The more I think about it, a reasonable solution might actually be to use threadlets for disk I/O and pure event based processing for networking. It is two different handling paths and non-unified, but that might be the price for good performance :-)
Well, it takes 20 lines of userspace C code to bring *unification* to the universe ;)
- Davide
Quoted 4 lines
The more I think about it, a reasonable solution might actually be to use threadlets for disk I/O and pure event based processing for networking. It is two different handling paths and non-unified, but that might be the price for good performance :-)
I generally agree, with some comments.
If we come to the decision that there are some message rates that are better suited to delivery into a user-read ring (10gige rx to kevent, say) then it doesn't seem like it would be much of a stretch to add a facility where syslet completion could be funneled into that channel as well.
I also wonder if there isn't some opportunity to cut down the number of syscalls / op in networking land. Is it madness to think of a call like recvmsgv() which could provide a vector of msghdrs? It might not make sense, but it might cut down on the per-op overhead for loads that know they're going to be heavy enough to get a decent amount of batching without fatally harming latency. Maybe those loads are rare..
- z
Quoted 6 lines · Ingo Molnar
Firstly, i dont think you are fully applying the syslet/threadlet model. There is no reason why an 'idle' client would have to use up a full thread! It all depends on how you use syslets/threadlets, and how (frequently) you queue back requests from cachemiss threads back to the primary thread. It is only the simplest queueing model where there is one thread per request that is currently blocked.
Quoted 8 lines
Syslets/threadlets do /not/ force request processing to be performed in the async context forever - the async thread could very much queue it back to the primary context. (That's in essence what Tux did.) So the same state-machine techniques can be applied on both the syslet and the threadlet model, but in much more natural (and thus lower overhead) points: /between/ system calls and not in the middle of them. There are a number of measures that can be used to keep the number of parallel threads down.
i think the best model here is to use kevents or epoll to discover accept()-able or recv()-able keepalive sockets, and to do the main request loop via syslets/threadlets, with a 'queue back to the main context if we went async and if the request is done' feedback mechanism that keeps the size of the pool down.
Ingo
Quoted 3 lines · Ingo Molnar
Secondly, even assuming lots of pending requests/async-threads and a naive queueing model, an open request will eat up resources on the server no matter what.
Another fundamental misconception. Kernel AIO is not for servers. One programmer in a hundred is working on a server codebase, and one in a thousand dares to touch server plumbing. Kernel AIO is for clients, especially when mated to GUIs with an event delivery mechanism. Ask yourself why the one and only thing that Windows NT has ever gotten right about networking is I/O completion ports.
Cheers,
- Michael
Quoted 8 lines · David Miller
From: Evgeniy Polyakov <[email protected]>
Date: Thu, 22 Feb 2007 15:39:30 +0300Quoted 4 lines
It does not matter - even with threads cost of having thousands of
threads is _too_ expensive. So, IMO, it is wrong to have to create 20k threads for the simple web server which only sends one index page to 80k connections with 4k connections per seconds rate.
Quoted 9 lines
Quoted 2 lines
Just have that example in mind - more than 20k blocks in 80k connections over gigabit lan, and it is likely optimistic result, when designing new type of AIO.
I totally agree with Evgeniy on these points.
Using things like syslets and threadlets for networking I/O is not a very good idea. Blocking is more the norm than the exception for networking I/O.
And for O_DIRECT, and for large storage systems which overwhelm caches. The optimize for the nonblocking case approach does not fit all workloads. And of course we have to be able to mix mostly-nonblocking threadlets and mostly-blocking O_DIRECT and networking.
Signature · 1 line
error compiling committee.c: too many arguments to function
Quoted 3 lines · Evgeniy Polyakov
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by
tcp_sendmsg()for slow clients - rescheduling will kill a machine.
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM - that's acceptable.)
Quoted 3 lines
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.
yeah. Note that you can have a million sleeping threads if you want, the scheduler wont care. What matters more is the amount of true concurrency that is present at any given time. But yes, i agree that overscheduling can be a problem.
btw., what is the measurement utility you are using with kevents ('ab' perhaps, with a high -c concurrency count?), and which webserver are you using? (light-httpd?)
Ingo
Quoted 7 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by
tcp_sendmsg()for slow clients - rescheduling will kill a machine.
Quoted 8 lines
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM - that's acceptable.)
I tried already :) - I just made a allocations atomic in tcp_sendmsg() and ended up with 1/4 of the sends blocking (I counted both allocation failure and socket queue overflow). Those 20k blocked requests were created in about 20 seconds, so roughly saying we have 1k of thread creation/freeing per second - do we want this?
Quoted 8 lines
Quoted 3 lines
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.yeah. Note that you can have a million sleeping threads if you want, the scheduler wont care. What matters more is the amount of true concurrency that is present at any given time. But yes, i agree that overscheduling can be a problem.
Before I started M:N threading library implementation I checked some threading perfomance of the current POSIX library - I created simple pool of threads and 'sent' a message between them using futex wait/wake (sema_post/wait) one-by-one, results are quite dissapointing - given that number of sleeping threads were about hundreds, kernel rescheduling is about 10 times slower than setjmp based (I think so) used in Erlang.
Above example is not 100% correct, I understand, but situation with thread-like AIO is much worse - it is possible that several threads will be ready simultaneous, so rescheduling between them will kill a performance.
Quoted 3 lines
btw., what is the measurement utility you are using with kevents ('ab' perhaps, with a high -c concurrency count?), and which webserver are you using? (light-httpd?)
Yes, it is ab and lighttpd, before it was httperf (unfair on high load due to poll/select usage) and own web server (evserver_kevent.c).
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 9 lines · Evgeniy Polyakov
Quoted 8 lines
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM - that's acceptable.)
Quoted 5 lines
I tried already :) - I just made a allocations atomic in
tcp_sendmsg()and ended up with 1/4 of the sends blocking (I counted both allocation failure and socket queue overflow). Those 20k blocked requests were created in about 20 seconds, so roughly saying we have 1k of thread creation/freeing per second - do we want this?
A dynamic pool will smooth thread creation/freeing up by a lot. And, in my box a *pthread* create/free takes ~10us, at 1000/s is 10ms, 1%. Bad, but not so aweful ;)
Look, I'm *definitely* not trying to advocate the use of async syscalls for network here, just pointing out that when we're talking about threads, Linux does a pretty good job.
- Davide
Quoted 6 lines · Davide Libenzi
Quoted 5 lines
I tried already :) - I just made a allocations atomic in
tcp_sendmsg()and ended up with 1/4 of the sends blocking (I counted both allocation failure and socket queue overflow). Those 20k blocked requests were created in about 20 seconds, so roughly saying we have 1k of thread creation/freeing per second - do we want this?
Quoted 6 lines
A dynamic pool will smooth thread creation/freeing up by a lot. And, in my box a *pthread* create/free takes ~10us, at 1000/s is 10ms, 1%. Bad, but not so aweful ;)
Look, I'm *definitely* not trying to advocate the use of async syscalls for network here, just pointing out that when we're talking about threads, Linux does a pretty good job.
If we are going to create 1000 threads each second, then it is better to preallocate them and queue a work to that pool - like syslets did with syscalls, but not ulitimately create a new thread just because it is not that slow.
All such micro-thread designs are especially good in the case when
1. switching is _rare_ (very)
2. programmer does not want to create complex model to achieve maximum performance
Disk (cached) IO definitely hits first entry and second one is there for advertisements and fast deployment, but overall usage of the asynchronous IO model is not limited to the above scenario, so micro-threads definitely hit own niche, but they can not cover all usage cases.
Quoted 3 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 9 lines · Evgeniy Polyakov
Quoted 7 lines · Davide Libenzi
A dynamic pool will smooth thread creation/freeing up by a lot. And, in my box a *pthread* create/free takes ~10us, at 1000/s is 10ms, 1%. Bad, but not so aweful ;)
Look, I'm *definitely* not trying to advocate the use of async syscalls for network here, just pointing out that when we're talking about threads, Linux does a pretty good job.
Quoted 4 lines
If we are going to create 1000 threads each second, then it is better to preallocate them and queue a work to that pool - like syslets did with syscalls, but not ulitimately create a new thread just because it is not that slow.
We do create a pool indeed, as I said in the opening of my asnwer. The numbers I posted was just to show that thread creation/destroy is pretty fast, but that does not justify it as a design choice.
Quoted 10 lines
All such micro-thread designs are especially good in the case when
1. switching is _rare_ (very)
2. programmer does not want to create complex model to achieve maximum performanceDisk (cached) IO definitely hits first entry and second one is there for advertisements and fast deployment, but overall usage of the asynchronous IO model is not limited to the above scenario, so micro-threads definitely hit own niche, but they can not cover all usage cases.
You know, I read this a few times, but I still don't get what your point is here ;) Are you talking about micro-thread design in the kernel as for kthreads usage for AIO, or about userspace?
- Davide
Quoted 11 lines · Davide Libenzi
Quoted 9 lines · Evgeniy Polyakov
Quoted 7 lines · Davide Libenzi
A dynamic pool will smooth thread creation/freeing up by a lot. And, in my box a *pthread* create/free takes ~10us, at 1000/s is 10ms, 1%. Bad, but not so aweful ;)
Look, I'm *definitely* not trying to advocate the use of async syscalls for network here, just pointing out that when we're talking about threads, Linux does a pretty good job.
Quoted 8 lines
Quoted 4 lines
If we are going to create 1000 threads each second, then it is better to preallocate them and queue a work to that pool - like syslets did with syscalls, but not ulitimately create a new thread just because it is not that slow.
We do create a pool indeed, as I said in the opening of my asnwer. The numbers I posted was just to show that thread creation/destroy is pretty fast, but that does not justify it as a design choice.
I was not clear - I meant why do we need to do that when we can run the same code in userspace? And better if we can have non-blocking dataflows and number of threads equal to number of processors...
Quoted 11 lines
Quoted 10 lines
All such micro-thread designs are especially good in the case when
1. switching is _rare_ (very)
2. programmer does not want to create complex model to achieve maximum performanceDisk (cached) IO definitely hits first entry and second one is there for advertisements and fast deployment, but overall usage of the asynchronous IO model is not limited to the above scenario, so micro-threads definitely hit own niche, but they can not cover all usage cases.
Quoted 3 lines
You know, I read this a few times, but I still don't get what your point is here ;) Are you talking about micro-thread design in the kernel as for kthreads usage for AIO, or about userspace?
I started a week of writing without russian-english dictionary, so expect some troubles in communications with me :)
I said that about kernel design - when we have thousand(s) of threads, which do the work - if number of context switches is small (i.e. when operations mostly do not block), then it is ok (although 'ps' output with threads can scary a grandma).
It is also ok to say - 'hey, Linux has so easy AIO model, so that everyone should switch and start using it and do not care about problems associated with multi-threaded programming with high concurrency', but, in my opinion, both that cases can not cover all (and most of) the usage cases.
To eat my hat (or force others to do the same) I'm preparing a tree for threadlet test - I plan to write a trivial web server (accept/recv/send/sendfile in one threadlet function) and give it a try soon.
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
I was not clear - I meant why do we need to do that when we can run the same code in userspace? And better if we can have non-blocking dataflows and number of threads equal to number of processors...
I've a userspace library that does exactly that (GUASI - GPL code avail if you want, but no man page written yet). It uses a pool of threads and queue requests. I've a bench that crawl through a directory a read files. The sync against async performance sucks. You can't do the cachehit optimization in userspace. With network stuff could prolly do better (since network is more heavily towards async), but still.
Quoted 13 lines
I started a week of writing without russian-english dictionary, so expect some troubles in communications with me :)
I said that about kernel design - when we have thousand(s) of threads, which do the work - if number of context switches is small (i.e. when operations mostly do not block), then it is ok (although 'ps' output with threads can scary a grandma).
It is also ok to say - 'hey, Linux has so easy AIO model, so that everyone should switch and start using it and do not care about problems associated with multi-threaded programming with high concurrency', but, in my opinion, both that cases can not cover all (and most of) the usage cases.
Quoted 4 lines
To eat my hat (or force others to do the same) I'm preparing a tree for threadlet test - I plan to write a trivial web server (accept/recv/send/sendfile in one threadlet function) and give it a try soon.
Funny, I lazily started doing the same thing last weekend (than I had to stop, since real job kicked in ;). I wanted to compare a fully MT trivial HTTP server:
http://www.xmailserver.org/thrhttp.c
with one that is event-driven (epoll) and coroutine based. This one will only be compared for memory-content delivery, since it has no async vfs capabilities. They both support the special "/mem-XXXX" url, that allows an HTTP loader to request a given content size.
I also have a epoll+coroutine HTTP loader (that works around httperf limitations).
Then, I wanted to compare the above, with one that is epoll+GUASI+coroutine based (basically a userpace-only thingy).
I've the code for all the above.
Finally, with one that is epoll+syslet+coroutine based (no code for this yet - but it should be a easy port from the GUASI one).
Keep in mind though, that a threadlet solution doing accept/recv/send/sendfile is becoming blazingly similar to a full MT solution.
I can only immagine the thunders and flames that Larry would throw at us for using all those threads :D
- Davide
Quoted 3 lines · Evgeniy Polyakov
[...] Those 20k blocked requests were created in about 20 seconds, so roughly saying we have 1k of thread creation/freeing per second - do we want this?
i'm not sure why you mention thread creation and freeing. The syslet/threadlet code reuses already created async threads, and that is visible all around in both the kernel-space and in the user-space syslet/threadlet code.
While Linux creates+destroys threads pretty damn fast (in about 10-15 usecs - which is roughly the cost of getting a single 1-byte packet through a TCP socket from one process to another, on localhost), still we dont want to create and destroy a thread per request.
Ingo
Quoted 9 lines · Ingo Molnar
Quoted 3 lines
[...] Those 20k blocked requests were created in about 20 seconds, so roughly saying we have 1k of thread creation/freeing per second - do we want this?
i'm not sure why you mention thread creation and freeing. The syslet/threadlet code reuses already created async threads, and that is visible all around in both the kernel-space and in the user-space syslet/threadlet code.
Quoted 4 lines
While Linux creates+destroys threads pretty damn fast (in about 10-15 usecs - which is roughly the cost of getting a single 1-byte packet through a TCP socket from one process to another, on localhost), still we dont want to create and destroy a thread per request.
I meant that we end up with having one thread per IO - they were preallocated, but that does not matter. And what about your idea of switching userspace threads to cachemiss threads?
My main concern was only about the situation, when we ends up with truly bloking context (like network), and this results in having thousands of threads doing the work - even having most of them sleeping, there is a problem with memory overhead and context switching, although it is usable situation, but when all of them are ready immediately - context switching will kill a machine even with O(1) scheduler which made situation damn better than before, but it is not a cure for the problem.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 9 lines · Evgeniy Polyakov
I meant that we end up with having one thread per IO - they were preallocated, but that does not matter. And what about your idea of switching userspace threads to cachemiss threads?
My main concern was only about the situation, when we ends up with truly bloking context (like network), and this results in having thousands of threads doing the work - even having most of them sleeping, there is a problem with memory overhead and context switching, although it is usable situation, but when all of them are ready immediately - context switching
simultaneously
Quoted 2 lines
will kill a machine even with O(1) scheduler which made situation damn better than before, but it is not a cure for the problem.
Week of no-dictionary writings starts beating me.
Signature · 1 line
Evgeniy Polyakov
Quoted 8 lines · Evgeniy Polyakov
My main concern was only about the situation, when we ends up with truly bloking context (like network), and this results in having thousands of threads doing the work - even having most of them sleeping, there is a problem with memory overhead and context switching, although it is usable situation, but when all of them are ready immediately - context switching will kill a machine even with O(1) scheduler which made situation damn better than before, but it is not a cure for the problem.
yes. This is why in the original fibril discussion i concentrated so much on scheduling performance.
to me the picture is this: conceptually the scheduler runqueue is a queue of work. You get items queued upon certain events, and they can unqueue themselves. (there is also register context but that is already optimized to death by hardware) So whatever scheduling overhead we have, it's a pure software thing. It's because we have priorities attached. It's because we have some legacies. Etc., etc. - it's all stuff /we/ wanted to add, but nothing truly fundamental on top of the basic 'work queueing' model.
now look at kevents as the queueing model. It does not queue 'tasks', it lets user-space queue requests in essence, in various states. But it's still the same conceptual thing: a memory buffer with some state associated to it. Yes, it has no legacies, it has no priorities and other queueing concepts attached to it ... yet. If kevents got mainstream, it would get the same kind of pressure to grow 'more advanced' event queueing and event scheduling capabilities. Prioritization would be needed, etc.
So my fundamental claim is: a kernel thread /is/ our main request structure. We've got tons of really good system calls that queue these 'requests' around the place and offer functionality around this concept. Plus there's a 1.2+ billion lines of Linux userspace code that works well with this abstraction - while there's nary a few thousand lines of event-based user-space code.
I also say that you'll likely get kevents outperform threadlets. Maybe even significantly so under the right conditions. But i very much believe we want to get similar kind of performance out of thread/task scheduling, and not introduce a parallel framework to do request scheduling the hard way ... just because our task concept and scheduling implementation got too fat. For the same reason i didnt really like
fibrils: they are nice, and Zach's core idea i think nicely survived in the syslet/threadlet model too, but they are more limited than true threads. So doing that parallel infrastructure, which really just implements the same, and is only faster because it skips features, would just be hiding the problem with our primary abstraction. Ok?
Ingo
Quoted 40 lines · Ingo Molnar
Quoted 8 lines · Evgeniy Polyakov
My main concern was only about the situation, when we ends up with truly bloking context (like network), and this results in having thousands of threads doing the work - even having most of them sleeping, there is a problem with memory overhead and context switching, although it is usable situation, but when all of them are ready immediately - context switching will kill a machine even with O(1) scheduler which made situation damn better than before, but it is not a cure for the problem.
yes. This is why in the original fibril discussion i concentrated so much on scheduling performance.
to me the picture is this: conceptually the scheduler runqueue is a queue of work. You get items queued upon certain events, and they can unqueue themselves. (there is also register context but that is already optimized to death by hardware) So whatever scheduling overhead we have, it's a pure software thing. It's because we have priorities attached. It's because we have some legacies. Etc., etc. - it's all stuff /we/ wanted to add, but nothing truly fundamental on top of the basic 'work queueing' model.
now look at kevents as the queueing model. It does not queue 'tasks', it lets user-space queue requests in essence, in various states. But it's still the same conceptual thing: a memory buffer with some state associated to it. Yes, it has no legacies, it has no priorities and other queueing concepts attached to it ... yet. If kevents got mainstream, it would get the same kind of pressure to grow 'more advanced' event queueing and event scheduling capabilities. Prioritization would be needed, etc.
So my fundamental claim is: a kernel thread /is/ our main request structure. We've got tons of really good system calls that queue these 'requests' around the place and offer functionality around this concept. Plus there's a 1.2+ billion lines of Linux userspace code that works well with this abstraction - while there's nary a few thousand lines of event-based user-space code.
Quoted 11 lines
I also say that you'll likely get kevents outperform threadlets. Maybe even significantly so under the right conditions. But i very much believe we want to get similar kind of performance out of thread/task scheduling, and not introduce a parallel framework to do request scheduling the hard way ... just because our task concept and scheduling implementation got too fat. For the same reason i didnt really like
fibrils: they are nice, and Zach's core idea i think nicely survived in the syslet/threadlet model too, but they are more limited than true threads. So doing that parallel infrastructure, which really just implements the same, and is only faster because it skips features, would just be hiding the problem with our primary abstraction. Ok?
Kevent is a _very_ small entity and there is _no_ cost of requeueing (well, there is list_add guarded by lock) - after it is done, process can start real work. With rescheduling there are _too_ many things to be done before we can start new work. We have to change registers, change address space, various tlb bits and so on - we have to do it, since task describes very heavy entity - the whole process.
IO in turn is a very small subset of what process is (can do), so there is no need to change the whole picture, so it is enough to have one process, which does the work.
Threads are a bit smaller than process, but still it is too heavy to have it per IO - so we have pools - this decreases rescheduling overhead, but limits parallelism.
I think it is _too_ heavy to have such a monster structure like task(thread/process) and related overhead just to do an IO.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 4 lines · Evgeniy Polyakov
Kevent is a _very_ small entity and there is _no_ cost of requeueing (well, there is
list_addguarded by lock) - after it is done, process can start real work. With rescheduling there are _too_ many things to be done before we can start new work. [...]
actually, no. For example a wakeup too is fundamentally a list_add guarded by a lock. Take a look at try_to_wake_up(). The rest you see there is just extra frills that relate to things like 'load-balancing the requests over multiple CPUs [which i'm sure kevent users would request in the future too]'.
Quoted 3 lines
[...] We have to change registers, change address space, various tlb bits and so on - we have to do it, since task describes very heavy entity - the whole process. [...]
but ... 'threadlets' are called thread-lets because they are not full processes, they are threads. There's no TLB state in that case. There's indeed register state associated with them, and currently there can certainly be quite a bit of overhead in a context switch - but not in register saving. We do user-space register saving not in the scheduler but upon /every system call/. Fundamentally a kernel thread is just its EIP/ESP [on x86, similar on other architectures] - which can be saved/restored in near zero time. All the rest is something we added for good /work queueing/ reasons - and those same extras should either be eliminated if they turn out to be not so good reasons after all, or they will be wanted for kevents too eventually, once it matures as a work queueing solution.
Quoted 2 lines
I think it is _too_ heavy to have such a monster structure like task(thread/process) and related overhead just to do an IO.
i think you are really, really mistaken if you believe that the fact that whole tasks/threads or processes can be 'monster structures', somehow has any relevance to scheduling/task-queueing performance and scalability. It does not matter how large a task's address space is - scheduling only relates to the minimal context that is in the CPU. And most of that context we save upon /every system call entry/, and restore it upon every system call return. If it's so expensive to manipulate, why can the Linux kernel do a full system call in ~150 cycles? That's cheaper than the access latency to a single DRAM page.
for the same reason has it no relevance that the full kevent-based webserver is a 'monster structure' - still a single request's basic queueing operation is cheap. The same is true to tasks/threads.
Really, you dont even have to know or assume anything about the scheduler, just lets do some elementary math here:
the reqs/sec your sendfile+kevent based webserver can do is 7900 per sec. Lets assume you will write further great kevent code which will optimize it further and it goes up to 10,100 reqs per sec (100 usecs per request), ok? Then also try how many reschedules/sec can your Athon64 3500 box do. My guess is: about a million per second (1 usec per reschedule), perhaps a bit more.
Now lets assume that a threadlet based server would have to context-switch for /every single/ request served. That's totally over-estimating it, even with lots of slow clients, but lets assume it, to judge the worst-case impact.
So if you had to schedule once per every request served, you'd have to add 1 usec to your 100 usecs cost, making it 101 usecs. That would bring your 10,100 requests per sec to 10,000 requests/sec, under a threadlet model of operation. Put differently: it will cost you only 1% in performance to schedule once for every request. Or lets assume the task is totally cache-cold and you'd have to add 4 usecs for its scheduling - that'd still only be 4%. So where is the fat?
Ingo
Quoted 8 lines · Ingo Molnar
Quoted 4 lines · Evgeniy Polyakov
Kevent is a _very_ small entity and there is _no_ cost of requeueing (well, there is
list_addguarded by lock) - after it is done, process can start real work. With rescheduling there are _too_ many things to be done before we can start new work. [...]
Quoted 5 lines
actually, no. For example a wakeup too is fundamentally a
list_addguarded by a lock. Take a look attry_to_wake_up(). The rest you see there is just extra frills that relate to things like 'load-balancing the requests over multiple CPUs [which i'm sure kevent users would request in the future too]'.
wake_up() as a call is pretty simple and fast, but its result - it is slow. I did not run reschedulingtests with kernel thread, but posix threads (they do look like a kernel thread) have significant overhead there. In early developemnt days of M:N threading library I tested rescheduling performance of the POSIX threads - I created pool of threads and 'sent' a message using futex wait/wake - such performance of the userspace threading library (I tested erlang) was 10 times slower.
Quoted 4 lines
Quoted 3 lines
[...] We have to change registers, change address space, various tlb bits and so on - we have to do it, since task describes very heavy entity - the whole process. [...]
Quoted 12 lines
but ... 'threadlets' are called thread-lets because they are not full processes, they are threads. There's no TLB state in that case. There's indeed register state associated with them, and currently there can certainly be quite a bit of overhead in a context switch - but not in register saving. We do user-space register saving not in the scheduler but upon /every system call/. Fundamentally a kernel thread is just its EIP/ESP [on x86, similar on other architectures] - which can be saved/restored in near zero time. All the rest is something we added for good /work queueing/ reasons - and those same extras should either be eliminated if they turn out to be not so good reasons after all, or they will be wanted for kevents too eventually, once it matures as a work queueing solution.
If things decreases performance noticebly, it is a bad things, but it is matter of taste. Anyway, kevents are very small, threads are very big, and both are the way they are exactly on purpose - threads serve for processing of any generic code, kevents are used for event waiting - IO is such an event, it does not require a lot of infrastructure to handle, it only nees some simple bits, so it can be optimized to be extremely fast, with huge infrastructure behind each IO (like in case when it is a separated thread) it can not be done effectively.
Quoted 12 lines
Quoted 2 lines
I think it is _too_ heavy to have such a monster structure like task(thread/process) and related overhead just to do an IO.
i think you are really, really mistaken if you believe that the fact that whole tasks/threads or processes can be 'monster structures', somehow has any relevance to scheduling/task-queueing performance and scalability. It does not matter how large a task's address space is - scheduling only relates to the minimal context that is in the CPU. And most of that context we save upon /every system call entry/, and restore it upon every system call return. If it's so expensive to manipulate, why can the Linux kernel do a full system call in ~150 cycles? That's cheaper than the access latency to a single DRAM page.
I meant not its size, but the whole infrastructure, which surrounds task. If it is that lightweight, why don't we have posix thread per IO? One question is that mmap/allocation of the stack is too slow (and it is very slow indeed, that is why glibc and M:N threading lib caches allocated stacks), another one is kernel/userspace boundary crossing, next one are tlb flushes, then copies.
Why userspace rescheduling is in order of tens times faster than kernel/user?
Quoted 3 lines
for the same reason has it no relevance that the full kevent-based webserver is a 'monster structure' - still a single request's basic queueing operation is cheap. The same is true to tasks/threads.
To move that tasks there must be done too may steps, and although each one can be quite fast, the whole process of rescheduling in the case of thousands running threads creates too big overhead per task to drop performance.
Quoted 9 lines
Really, you dont even have to know or assume anything about the scheduler, just lets do some elementary math here:
the reqs/sec your sendfile+kevent based webserver can do is 7900 per sec. Lets assume you will write further great kevent code which will optimize it further and it goes up to 10,100 reqs per sec (100 usecs per request), ok? Then also try how many reschedules/sec can your Athon64 3500 box do. My guess is: about a million per second (1 usec per reschedule), perhaps a bit more.
Let's calculate: disk bandwidth is about gigabytes per second (cached case), so to transfer 10k file we need about 10 usec - 10% of it will be spent in rescheduling (if there will be only one if any). Network is an order of 10 slower (1gbit for example), but there are much more blockings, so to transfer 10k we will have let's say 5 blocks, i.e. 5 reschedulings - another 5%, so we wasted 15% of our time in rescheduling.
Event in turn is a 30 bytes copy (plus of course own overhead, but it is still faster - it is faster just because ukevet size is smaller than pt_regs :).
Interesting discussion, that will be very fun if kevent will lose badly :)
Quoted 5 lines
Now lets assume that a threadlet based server would have to context-switch for /every single/ request served. That's totally over-estimating it, even with lots of slow clients, but lets assume it, to judge the worst-case impact.
Quoted 7 lines
So if you had to schedule once per every request served, you'd have to add 1 usec to your 100 usecs cost, making it 101 usecs. That would bring your 10,100 requests per sec to 10,000 requests/sec, under a threadlet model of operation. Put differently: it will cost you only 1% in performance to schedule once for every request. Or lets assume the task is totally cache-cold and you'd have to add 4 usecs for its scheduling - that'd still only be 4%. So where is the fat?
I need to move home or I will sleep on the street, otherwise I would already ran a test and started to eat a hat (present me a red one like Lan Cox had), or watch how you to do it :)
Give me several hours.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 2 lines · Evgeniy Polyakov
Interesting discussion, that will be very fun if kevent will lose badly :)
with your keepalive test no way can it lose against 80,000 sync threadlets - it's pretty much the worst-case thing for threadlets while it's the best-case for kevents. Try a non-keepalive test perhaps?
Ingo
Quoted 5 lines · Evgeniy Polyakov
Quoted 5 lines
Quoted 4 lines
Kevent is a _very_ small entity and there is _no_ cost of requeueing (well, there is
list_addguarded by lock) - after it is done, process can start real work. With rescheduling there are _too_ many things to be done before we can start new work. [...]
Quoted 8 lines
Quoted 5 lines
actually, no. For example a wakeup too is fundamentally a
list_addguarded by a lock. Take a look attry_to_wake_up(). The rest you see there is just extra frills that relate to things like 'load-balancing the requests over multiple CPUs [which i'm sure kevent users would request in the future too]'.
wake_up()as a call is pretty simple and fast, but its result - it is slow. [...]
You are still very much wrong, and now you refuse to even /read/ what i wrote. Your only reply to my detailed analysis is: "it is slow, because it is slow and heavy". I told you how fast it is, i told you what happens on a context switch and why, i told you that you can measure if you want.
Quoted 3 lines
[...] I did not run reschedulingtests with kernel thread, but posix threads (they do look like a kernel thread) have significant overhead there.
You are wrong. Let me show you some more numbers. This is a hackbench_pth.c run:
$ ./hackbench_pth 500 Time: 14.371
this uses 20,000 real threads and during this test the runqueue length is extreme - up to over a ten thousand threads. (hackbench_pth.c was posted to lkml recently.
The same run with hackbench.c (20,000 forked processes):
$ ./hackbench 500 Time: 14.632
so the TLB overhead from using processes is 1.8%.
Quoted 5 lines
[...] In early developemnt days of M:N threading library I tested rescheduling performance of the POSIX threads - I created pool of threads and 'sent' a message using futex wait/wake - such performance of the userspace threading library (I tested erlang) was 10 times slower.
how much would it take for you to actually re-measure it and interpet the results you are seeing? You've apparently built a whole mental house of cards on the flawed proposition that tasks are 'super-heavy' and that context-switching them is 'slow'. You are unwilling to explain /how/ they are slow, and all the numbers i post are contrary to that proposition of yours.
your whole reasoning seems to be faith-based:
[...] Anyway, kevents are very small, threads are very big, [...]
How about following the scientific method instead?
Quoted 6 lines
[...] and both are the way they are exactly on purpose - threads serve for processing of any generic code, kevents are used for event waiting
- IO is such an event, it does not require a lot of infrastructure to handle, it only nees some simple bits, so it can be optimized to be extremely fast, with huge infrastructure behind each IO (like in case when it is a separated thread) it can not be done effectively.
you are wrong, and i have pointed it out to you in my previous replies why you are wrong. Your only coherent specific thought on this topic was your incorrect assumption is that the scheduler somehow saves registers and that this makes it heavy. I pointed it out to you in the mail you reply to that /every/ system call that saves user registers. You've not even replied to that point of mine, you are ignoring it completely and you are still repeating your same old, incorrect argument. If it is heavy, /why/ do you think it is heavy? Where is that magic pixie dust piece of scheduler code that miraculously turns the runqueue into a molass slow, heavy piece of thing?
Or put in another way: your test-code does ~6 syscalls per every event. So if what you said would be true (which it isnt), a kevent based request would have be just as slow as thread based request ...
Quoted 11 lines
Quoted 10 lines
i think you are really, really mistaken if you believe that the fact that whole tasks/threads or processes can be 'monster structures', somehow has any relevance to scheduling/task-queueing performance and scalability. It does not matter how large a task's address space is - scheduling only relates to the minimal context that is in the CPU. And most of that context we save upon /every system call entry/, and restore it upon every system call return. If it's so expensive to manipulate, why can the Linux kernel do a full system call in ~150 cycles? That's cheaper than the access latency to a single DRAM page.
Quoted 2 lines
I meant not its size, but the whole infrastructure, which surrounds task. [...]
/what/ infrastructure do you mean? sched.c? Most of that never runs in the scheduler hotpath.
Quoted 2 lines
[...] If it is that lightweight, why don't we have posix thread per IO? [...]
because it would be pretty stupid to do that?
But more importantly: because many people still believe 'the scheduler is slow and context-switching is evil'? The FIO AIO syslet code from Jens is an intelligent mix of queueing combined with async execution. I expect that model to prevail.
Quoted 4 lines
[...] One question is that mmap/allocation of the stack is too slow (and it is very slow indeed, that is why glibc and M:N threading lib caches allocated stacks), another one is kernel/userspace boundary crossing, next one are tlb flushes, then copies.
now you come up again with creation overhead but nobody is talking about context creation overhead. (btw., you are also wrong if you think that mmap() is all that slow - try measuring it one day) We were talking about context /switching/.
Quoted 2 lines
Why userspace rescheduling is in order of tens times faster than kernel/user?
what on earth does this have to do with the topic of whether context switches are fast enough? Or if you like random info, just let me throw in a random piece of information as well:
user-space function calls are more than /two/ orders of magnitude faster than system calls. Still you are using 6 ... SIX system calls in the sample kevent request handling hotpath.
Quoted 8 lines
Quoted 3 lines
for the same reason has it no relevance that the full kevent-based webserver is a 'monster structure' - still a single request's basic queueing operation is cheap. The same is true to tasks/threads.
To move that tasks there must be done too may steps, and although each one can be quite fast, the whole process of rescheduling in the case of thousands running threads creates too big overhead per task to drop performance.
again, please come up with specifics! I certainly came up with enough specifics.
Ingo
Quoted 14 lines · Ingo Molnar
Quoted 11 lines · Evgeniy Polyakov
Quoted 10 lines
Quoted 4 lines
Kevent is a _very_ small entity and there is _no_ cost of requeueing (well, there is
list_addguarded by lock) - after it is done, process can start real work. With rescheduling there are _too_ many things to be done before we can start new work. [...]actually, no. For example a wakeup too is fundamentally a
list_addguarded by a lock. Take a look attry_to_wake_up(). The rest you see there is just extra frills that relate to things like 'load-balancing the requests over multiple CPUs [which i'm sure kevent users would request in the future too]'.
Quoted 8 lines
Quoted 2 lines
wake_up()as a call is pretty simple and fast, but its result - it is slow. [...]You are still very much wrong, and now you refuse to even /read/ what i wrote. Your only reply to my detailed analysis is: "it is slow, because it is slow and heavy". I told you how fast it is, i told you what happens on a context switch and why, i told you that you can measure if you want.
Ingo, you likely will not believe, but your mails are ones of the several which I always read several times to get every bit of it :)
I clearly understand your point of view, it is absoutely clear and shine for me. But... I can not agree with it.
Because of theoretical point of view and practical one concerned my measurements. It is not pure speculation, which one can expect, but real life comparison of kernel/user scheduling with pure userspace one (like in own M:N threading lib or concurrent prgramming language like erlang). For me (and probably _only_ for me), it is enough to show that some lib shows 10 times faster rescheduling to start developing own, so I pointed to it in a discussion.
Quoted 34 lines
Quoted 3 lines
[...] I did not run reschedulingtests with kernel thread, but posix threads (they do look like a kernel thread) have significant overhead there.
You are wrong. Let me show you some more numbers. This is a
hackbench_pth.crun:$ ./hackbench_pth 500 Time: 14.371this uses 20,000 real threads and during this test the runqueue length is extreme - up to over a ten thousand threads. (
hackbench_pth.cwas posted to lkml recently.The same run with
hackbench.c(20,000 forked processes):$ ./hackbench 500 Time: 14.632so the TLB overhead from using processes is 1.8%.
Quoted 5 lines
[...] In early developemnt days of M:N threading library I tested rescheduling performance of the POSIX threads - I created pool of threads and 'sent' a message using futex wait/wake - such performance of the userspace threading library (I tested erlang) was 10 times slower.
how much would it take for you to actually re-measure it and interpet the results you are seeing? You've apparently built a whole mental house of cards on the flawed proposition that tasks are 'super-heavy' and that context-switching them is 'slow'. You are unwilling to explain /how/ they are slow, and all the numbers i post are contrary to that proposition of yours.
Quoted 5 lines
your whole reasoning seems to be faith-based:
[...] Anyway, kevents are very small, threads are very big, [...]
How about following the scientific method instead?
That are only rethorical words as you have understood I bet, I meant that the whole process of getting readiness notification from kevent is way tooo much faster than resheduling of the new process/thread to handle that IO.
The whole process of switching from one process to another can be as fast as bloody hell, but all other details just kill the thing.
I do not know, what exact line ends up with problem, but having thousands of threads, rescheduling itself, results in slower performance than userspace rescheduling. Then I interpolate it to our IO test case.
Quoted 7 lines
Quoted 6 lines
[...] and both are the way they are exactly on purpose - threads serve for processing of any generic code, kevents are used for event waiting
- IO is such an event, it does not require a lot of infrastructure to handle, it only nees some simple bits, so it can be optimized to be extremely fast, with huge infrastructure behind each IO (like in case when it is a separated thread) it can not be done effectively.
Quoted 10 lines
you are wrong, and i have pointed it out to you in my previous replies why you are wrong. Your only coherent specific thought on this topic was your incorrect assumption is that the scheduler somehow saves registers and that this makes it heavy. I pointed it out to you in the mail you reply to that /every/ system call that saves user registers. You've not even replied to that point of mine, you are ignoring it completely and you are still repeating your same old, incorrect argument. If it is heavy, /why/ do you think it is heavy? Where is that magic pixie dust piece of scheduler code that miraculously turns the runqueue into a molass slow, heavy piece of thing?
I do not arue that I'm absolutely right.
I just point that I tested some cases and that tests ends up with completely broken behaviour for micro-thread design (even besides the case of thousand of new thread creation/reuse per second, which itself does not look perfect).
I do not even ever try to say that threadlets suck (although I do believe that it is in some cases, at leat for now :) ), I just point that rescheduling overhead happens to be tooo big when it comes to benchmarks I ran (where you never replied too, but that does not matter after all :).
It can end up with (handwaving) broken syscall wrapper implementation, or with anything else. Absolutely.
I never ever tried to say that scheduler's code is broken - I just show my own tests which resulted in the situation, when many working threads can end up with timings worse than some other case.
Register/tlb/whatever is just a speculation about _possible _ root of the problem. I did not investigate problem enough - I just decided to implement different library. Shame on me for that, since I never showed what exactly is a root of the problem, but for _me_ it is enough, so I'm trying to share it with you and other developers.
Quoted 3 lines
Or put in another way: your test-code does ~6 syscalls per every event. So if what you said would be true (which it isnt), a kevent based request would have be just as slow as thread based request ...
I can neither confirm nor object against this sentence.
Quoted 20 lines
Quoted 11 lines
Quoted 10 lines
i think you are really, really mistaken if you believe that the fact that whole tasks/threads or processes can be 'monster structures', somehow has any relevance to scheduling/task-queueing performance and scalability. It does not matter how large a task's address space is - scheduling only relates to the minimal context that is in the CPU. And most of that context we save upon /every system call entry/, and restore it upon every system call return. If it's so expensive to manipulate, why can the Linux kernel do a full system call in ~150 cycles? That's cheaper than the access latency to a single DRAM page.
Quoted 2 lines
I meant not its size, but the whole infrastructure, which surrounds task. [...]
/what/ infrastructure do you mean?
sched.c? Most of that never runs in the scheduler hotpath.Quoted 2 lines
[...] If it is that lightweight, why don't we have posix thread per IO? [...]
Quoted 6 lines
because it would be pretty stupid to do that?
But more importantly: because many people still believe 'the scheduler is slow and context-switching is evil'? The FIO AIO syslet code from Jens is an intelligent mix of queueing combined with async execution. I expect that model to prevail.
Suparna showed its problems - although on an older version. Let's see another tests.
Quoted 9 lines
Quoted 4 lines
[...] One question is that mmap/allocation of the stack is too slow (and it is very slow indeed, that is why glibc and M:N threading lib caches allocated stacks), another one is kernel/userspace boundary crossing, next one are tlb flushes, then copies.
now you come up again with creation overhead but nobody is talking about context creation overhead. (btw., you are also wrong if you think that
mmap()is all that slow - try measuring it one day) We were talking about context /switching/.
Ugh, Ingo, do not think absolutely...
I did it. And it is slow.
http://tservice.net.ru/~s0mbre/blog/2007/01/15#2007_01_15
Quoted 10 lines
Quoted 2 lines
Why userspace rescheduling is in order of tens times faster than kernel/user?
what on earth does this have to do with the topic of whether context switches are fast enough? Or if you like random info, just let me throw in a random piece of information as well:
user-space function calls are more than /two/ orders of magnitude faster than system calls. Still you are using 6 ... SIX system calls in the sample kevent request handling hotpath.
I can only laugh on that, Ingo :)
If you will be in Moscow, I will buy you a beer, just drop me a mail.
What we are talking about, Ingo, kevent and IO in thread contexts, or userspace vs. kernelspace scheduling?
Kevent can be broken as hell, it can be stupid application, which does not work at all - it is one of the possible theories. Practice however shows that it is not true.
Anyway, if we are talking about kevents and micro-threads, that is one point, if we are talking about possible overhead of rescheduling - it is another topic.
Quoted 11 lines
Quoted 8 lines
Quoted 3 lines
for the same reason has it no relevance that the full kevent-based webserver is a 'monster structure' - still a single request's basic queueing operation is cheap. The same is true to tasks/threads.
To move that tasks there must be done too may steps, and although each one can be quite fast, the whole process of rescheduling in the case of thousands running threads creates too big overhead per task to drop performance.
again, please come up with specifics! I certainly came up with enough specifics.
I thought I showed it several times already.
Anyway: http://tservice.net.ru/~s0mbre/blog/2006/11/09#2006_11_09
That is an initial step, which shows that rescheduling of threads ( I DO NOT say about problems in sched.c, Ingo, that would be somehow stupid, althogh can be right) has some overhead comapred to userspace rescheduling. If so, it can be eliminated or reduced.
Second (COMPELTELY DIFFERENT STARTING POINT).
If rescheduling has some overhead, is it possible to reduce it using different model for IO? So I created kevent (as you likely do not know, original idea was a bit differnet - network AIO, but results is quite good).
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · Evgeniy Polyakov
Quoted 5 lines
your whole reasoning seems to be faith-based:
[...] Anyway, kevents are very small, threads are very big, [...]
How about following the scientific method instead?
Quoted 7 lines
That are only rethorical words as you have understood I bet, I meant that the whole process of getting readiness notification from kevent is way tooo much faster than resheduling of the new process/thread to handle that IO.
The whole process of switching from one process to another can be as fast as bloody hell, but all other details just kill the thing.
for our primary abstractions there /IS NO OTHER DETAIL/ but wakeup and context-switching! The "event notification" of a sys_read() /IS/ the wakeup and context-switching that we do - or the epoll/kevent enqueueing as an alternative.
yes, the two are still different in a number of ways, and yes, it's still stupid to do a pool of thousands of threads and thus we can always optimize queuing, RAM and cache footprint via specialization, but your whole foundation seems to be constructed around the false notion that queueing and scheduling a task by the scheduler is somehow magically expensive and different from queueing and scheduling other type of requests. Please reconsider that foundation and open up a bit more to a slightly different world view: scheduling is really just another, more generic (and thus certainly more expensive) type of 'request queueing', and user-space, most of the time, is much better off if it handles its 'requests' and 'events' via tasks. (Especially if many of those 'events' turn out to be non-events at all, so to speak.)
Ingo
Quoted 19 lines · Ingo Molnar
Quoted 6 lines
Quoted 5 lines
your whole reasoning seems to be faith-based:
[...] Anyway, kevents are very small, threads are very big, [...]
How about following the scientific method instead?
Quoted 7 lines
That are only rethorical words as you have understood I bet, I meant that the whole process of getting readiness notification from kevent is way tooo much faster than resheduling of the new process/thread to handle that IO.
The whole process of switching from one process to another can be as fast as bloody hell, but all other details just kill the thing.
for our primary abstractions there /IS NO OTHER DETAIL/ but wakeup and context-switching! The "event notification" of a
sys_read()/IS/ the wakeup and context-switching that we do - or the epoll/kevent enqueueing as an alternative.
Quoted 12 lines
yes, the two are still different in a number of ways, and yes, it's still stupid to do a pool of thousands of threads and thus we can always optimize queuing, RAM and cache footprint via specialization, but your whole foundation seems to be constructed around the false notion that queueing and scheduling a task by the scheduler is somehow magically expensive and different from queueing and scheduling other type of requests. Please reconsider that foundation and open up a bit more to a slightly different world view: scheduling is really just another, more generic (and thus certainly more expensive) type of 'request queueing', and user-space, most of the time, is much better off if it handles its 'requests' and 'events' via tasks. (Especially if many of those 'events' turn out to be non-events at all, so to speak.)
If kernelspace rescheduling is that fast, then please explain me why userspace one always beats kernel/userspace?
And you showed that threadlets without polling accept still does not scale good - if it is the same fast queueing of events, then why doesn't it work?
Actually it does not matter, if that narrow place exist (like kernel/user transformation, or register copy or something else), it can be eliminated in different model - kevent is that model - it does not require a lot of things to be changed to get notification and start working, so it scales better.
It is very similar to epoll, but there are at least two significant moments:
1. it can work with _any_ type of events with minimal overhead (can not be even remotely compared with 'file' binding which is required to be pollable).
2. its notifications do not go through the second loop, i.e. it is O(1), not O(ready_num), and notifications happens directly from internals of the appropriate subsystem, which does not require special wakeup (although it can be done too).
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 2 lines · Evgeniy Polyakov
If kernelspace rescheduling is that fast, then please explain me why userspace one always beats kernel/userspace?
because 'user space scheduling' makes no sense? I explained my thinking about that in a past mail:
-------------------------->
One often repeated (because pretty much only) performance advantage of 'light threads' is context-switch performance between user-space threads. But reality is, nobody /cares/ about being able to context-switch between "light user-space threads"! Why? Because there are only two reasons why such a high-performance context-switch would occur:
1) there's contention between those two tasks. Wonderful: now two artificial threads are running on the /same/ CPU and they are even contending each other. Why not run a single context on a single CPU instead and only get contended if /another/ CPU runs a conflicting context?? While this makes for nice "pthread locking benchmarks", it is not really useful for anything real.
2) there has been an IO event. The thing is, for IO events we enter the kernel no matter what - and we'll do so for the next 10 years at minimum. We want to abstract away the hardware, we want to do reliable resource accounting, we want to share hardware resources, we want to rate-limit, etc., etc. While in /theory/ you could handle IO purely from user-space, in practice you dont want to do that. And if we accept the premise that we'll enter the kernel anyway, there's zero performance difference between scheduling right there in the kernel, or returning back to user-space to schedule there. (in fact i submit that the former is faster). Or if we accept the theoretical possibility of 'perfect IO hardware' that implements /all/ the features that the kernel wants (in a secure and generic way, and mind you, such IO hardware does not exist yet), then /at most/ the performance advantage of user-space doing the scheduling is the overhead of a null syscall entry. Which is a whopping 100 nsecs on modern CPUs! That's roughly the latency of a /single/ DRAM access!
....
<-----------
(see http://lwn.net/Articles/219958/)
btw., the words that follow that section are quite interesting in retrospect:
| Furthermore, 'light thread' concepts can no way approach the | performance of #2 state-machines: if you /know/ what the structure of | your context is, and you can program it in a specialized state-machine | way, there's just so many shortcuts possible that it's not even funny.
[ oops! ;-) ]
i severely under-estimated the kind of performance one can reach even with pure procedural concepts. Btw., when i wrote this mail was when i started thinking about "is it really true that the only way to get good performance are 100% event-based servers and nonblocking designs?", and started coding syslets and then threadlets.
Ingo
Quoted 15 lines · Ingo Molnar
Quoted 2 lines · Evgeniy Polyakov
If kernelspace rescheduling is that fast, then please explain me why userspace one always beats kernel/userspace?
because 'user space scheduling' makes no sense? I explained my thinking about that in a past mail:
-------------------------->
One often repeated (because pretty much only) performance advantage of 'light threads' is context-switch performance between user-space threads. But reality is, nobody /cares/ about being able to context-switch between "light user-space threads"! Why? Because there are only two reasons why such a high-performance context-switch would occur:
...
Quoted 8 lines
2) there has been an IO event. The thing is, for IO events we enter the kernel no matter what - and we'll do so for the next 10 years at minimum. We want to abstract away the hardware, we want to do reliable resource accounting, we want to share hardware resources, we want to rate-limit, etc., etc. While in /theory/ you could handle IO purely from user-space, in practice you dont want to do that. And if we accept the premise that we'll enter the kernel anyway, there's zero performance difference between scheduling right there in the
Quoted 8 lines
kernel, or returning back to user-space to schedule there. (in fact i submit that the former is faster). Or if we accept the theoretical possibility of 'perfect IO hardware' that implements /all/ the features that the kernel wants (in a secure and generic way, and mind you, such IO hardware does not exist yet), then /at most/ the performance advantage of user-space doing the scheduling is the overhead of a null syscall entry. Which is a whopping 100 nsecs on modern CPUs! That's roughly the latency of a /single/ DRAM access!
Ingo and Evgeniy,
I was trying to avoid getting into this discussion, but whatever. M:N threading systems also require just about all of the threading semantics that are inside the kernel to be available in userspace. Implementations of the userspace scheduler side of things must be able to turn off preemption to do per CPU local storage, report blocking/preempting via (via upcall or a mailbox) and other scheduler-ish things in reliable way so that the complexity of a system like that ends up not being worth it and is often monsteriously large to implement and debug. That's why Solaris 10 removed their scheduler activations framework and went with 1:1 like in Linux since the scheduler activations model is so difficult to control. The slowness of the futex stuff might be compounded by some VM mapping issues that Bill Irwin and Peter Ziljstra have pointed out in the past regard, if I understand correctly.
Bryan Cantril of Solaris 10/dtrace fame can comment on that if you ask him sometime.
For an exercise, think about all of things you need to either migrate or to do a cross CPU wake of a task. It goes to hell in complexity really quick. Erlang and other language based concurrency systems get their regularities by indirectly oversimplifying what threading is from what kernel folks are use to. Try doing a cross CPU wake quickly a system like that, good luck. Now think about how to do an IPI in userspace ? Good luck.
That's all :)
bill
Quoted 14 lines · Ingo Molnar
Quoted 2 lines
If kernelspace rescheduling is that fast, then please explain me why userspace one always beats kernel/userspace?
because 'user space scheduling' makes no sense? I explained my thinking about that in a past mail:
-------------------------->
One often repeated (because pretty much only) performance advantage of 'light threads' is context-switch performance between user-space threads. But reality is, nobody /cares/ about being able to context-switch between "light user-space threads"! Why? Because there are only two reasons why such a high-performance context-switch would occur:
Quoted 6 lines
1) there's contention between those two tasks. Wonderful: now two artificial threads are running on the /same/ CPU and they are even contending each other. Why not run a single context on a single CPU instead and only get contended if /another/ CPU runs a conflicting context?? While this makes for nice "pthread locking benchmarks", it is not really useful for anything real.
Obviously there must be several real threads, each of them can reschedule userspace threads, because it is fast and scalable.
So, one CPU - one real thread.
Quoted 9 lines
2) there has been an IO event. The thing is, for IO events we enter the kernel no matter what - and we'll do so for the next 10 years at minimum. We want to abstract away the hardware, we want to do reliable resource accounting, we want to share hardware resources, we want to rate-limit, etc., etc. While in /theory/ you could handle IO purely from user-space, in practice you dont want to do that. And if we accept the premise that we'll enter the kernel anyway, there's zero performance difference between scheduling right there in the kernel, or returning back to user-space to schedule there. (in fact
Quoted 8 lines
i submit that the former is faster). Or if we accept the theoretical possibility of 'perfect IO hardware' that implements /all/ the features that the kernel wants (in a secure and generic way, and mind you, such IO hardware does not exist yet), then /at most/ the performance advantage of user-space doing the scheduling is the overhead of a null syscall entry. Which is a whopping 100 nsecs on modern CPUs! That's roughly the latency of a /single/ DRAM access!
....
And here were start our discussion again from the begining :) We entered kernel, of course, but then kernel decides to move thread away and put another one on its place under hardware sun - so kernel starts to move registers, change some states and so on.
While in case of userspace threads we arelady returned back to userspace (on behalf of written above overhead) and start doing new task - move registers, change some states and so one.
And somehow it happens that doing it in userspace (for example with setjmp/longjmp) is faster than in kernel. I do not know why - I never investigated that case, but that is it.
Quoted 12 lines
<-----------
(see http://lwn.net/Articles/219958/)
btw., the words that follow that section are quite interesting in retrospect:
| Furthermore, 'light thread' concepts can no way approach the | performance of #2 state-machines: if you /know/ what the structure of | your context is, and you can program it in a specialized state-machine | way, there's just so many shortcuts possible that it's not even funny.
Quoted 7 lines
[ oops! ;-) ]
i severely under-estimated the kind of performance one can reach even with pure procedural concepts. Btw., when i wrote this mail was when i started thinking about "is it really true that the only way to get good performance are 100% event-based servers and nonblocking designs?", and started coding syslets and then threadlets.
:-)
Threads happen to be really fast, and easy to programm, but the maximum performance still can not be achieved with them just because event handling is faster - read one cacheline from the ring or queue, or reschedule threads?
Anyway, what we are talking about, Ingo?
I understand your point, I also understand that you are not going to change it (yes, that's it, but I need to confirm that I'm guilty too - I doubtly will think that thousands of threads doing IO is a win), so we can close the discussion at this point.
My main point in participating in it was kevent introduction - although I created kevent AIO as a state machine, I never wanted to promote kevent as AIO - kevent is event processing mechanism, one of its usage models is AIO, another ones are signals, file events, timers, whatever... You drawn a line - kevent is not needed - that is your point. I wanted to hear definitive wordsa half a year ago, but community kept silence. Eventually things are done.
Thanks.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Hi!
Quoted 5 lines
Quoted 2 lines
If kernelspace rescheduling is that fast, then please explain me why userspace one always beats kernel/userspace?
because 'user space scheduling' makes no sense? I explained my thinking about that in a past mail:
...
Quoted 2 lines
2) there has been an IO event. The thing is, for IO events we enter the kernel no matter what - and we'll do so for the next 10 years at
..actually, at some point 3D acceleration was done by accessing hw directly from userspace. OTOH I think we are moving away from that model, so it is probably irrelevant here.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 4 lines · Evgeniy Polyakov
2. its notifications do not go through the second loop, i.e. it is O(1), not
O(ready_num), and notifications happens directly from internals of the appropriate subsystem, which does not require special wakeup (although it can be done too).
Sorry if I do not read kevent code correctly, but in kevent_user_wait() there is a:
while (num < max_nr && ((k = kevent_dequeue_ready(u)) != NULL)) {
...
}loop, that make it O(ready_num). From a mathematical standpoint, they're both O(ready_num), but epoll is doing three passes over the ready set. I always though that if the number of ready events is so big that the more passes over the ready set becomes relevant, probably the "work" done by userspace for each fetched event would make the extra cost irrelevant. But that can be fixed by a patch that will follow on lkml ...
- Davide
Quoted 14 lines · Davide Libenzi
Quoted 4 lines · Evgeniy Polyakov
2. its notifications do not go through the second loop, i.e. it is O(1), not
O(ready_num), and notifications happens directly from internals of the appropriate subsystem, which does not require special wakeup (although it can be done too).Sorry if I do not read kevent code correctly, but in
kevent_user_wait()there is a:while (num < max_nr && ((k = kevent_dequeue_ready(u)) != NULL)) { ... }
Quoted 6 lines
loop, that make it
O(ready_num). From a mathematical standpoint, they're bothO(ready_num), but epoll is doing three passes over the ready set. I always though that if the number of ready events is so big that the more passes over the ready set becomes relevant, probably the "work" done by userspace for each fetched event would make the extra cost irrelevant. But that can be fixed by a patch that will follow on lkml ...
No, kevent_dequeue_ready() copies data to userspace, that is it. So it looks roughly following:
storage is ready: -> kevent_requee() - ends up in ading event to the end of the queue (list add under spinlock)
kevent_wait() -> copy first, second, ...
Kevent poll (as long as epoll) model requires _additional_ check in userspace context before it is copied, so we endup with checking the full ready queue again - that what I pointed as O(ready_num), O() implies price for copying to userspace, list_add and so on.
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 22 lines · Evgeniy Polyakov
Quoted 14 lines · Davide Libenzi
Quoted 4 lines · Evgeniy Polyakov
2. its notifications do not go through the second loop, i.e. it is O(1), not
O(ready_num), and notifications happens directly from internals of the appropriate subsystem, which does not require special wakeup (although it can be done too).Sorry if I do not read kevent code correctly, but in
kevent_user_wait()there is a:while (num < max_nr && ((k = kevent_dequeue_ready(u)) != NULL)) { ... }Quoted 6 lines
loop, that make it
O(ready_num). From a mathematical standpoint, they're bothO(ready_num), but epoll is doing three passes over the ready set. I always though that if the number of ready events is so big that the more passes over the ready set becomes relevant, probably the "work" done by userspace for each fetched event would make the extra cost irrelevant. But that can be fixed by a patch that will follow on lkml ...
Quoted 2 lines
No,
kevent_dequeue_ready()copies data to userspace, that is it. So it looks roughly following:
In all the books where I studied, the algorithms below would be classified as O(num_ready) ones:
[sys_kevent_wait]
+ for (i=0; i<num; ++i) {
+ k = kevent_dequeue_ready_ring(u);
+ if (!k)
+ break;
+ kevent_complete_ready(k);
+
+ if (k->event.ret_flags & KEVENT_RET_COPY_FAILED)
+ break;
+ kevent_stat_ring(u);
+ copied++;
+ }
[kevent_user_wait]
+ while (num < max_nr && ((k = kevent_dequeue_ready(u)) != NULL)) {
+ if (copy_to_user(buf + num*sizeof(struct ukevent),
+ &k->event, sizeof(struct ukevent))) {
+ if (num == 0)
+ num = -EFAULT;
+ break;
+ }
+ kevent_complete_ready(k);
+ ++num;
+ kevent_stat_wait(u);
+ }
It does not matter if inside the loop you invert a 20Kx20K matrix or you copy a byte, they both are O(num_ready).
- Davide
Quoted 2 lines · Davide Libenzi
It does not matter if inside the loop you invert a 20Kx20K matrix or you copy a byte, they both are
O(num_ready).
I probably selected wrong words to desribe, here is in details how kevent differs from epoll.
Polling case need to perform additional check before event can be copied to userspace, that check must be done for each even being copied. Kevent does not need that (it needs it for poll emulation) - if event is ready, then it is ready.
sys_poll() create a wait queue where different events (callbacks for them) are stored, when driver calls wake_up() appropriate event is added to the ready list and calls wake_up() for that wait queue, which in turn calls ->poll for each event and transfer it to userspace if it is ready.
Kevent works slightly different - it does not perform additional check for readiness (although it can, and it does in poll notifications), if event is marked as ready, parked in waiting syscal thread is awakened and event is copied to userspace.
Also waiting syscall is awakened through one queue - event is added and wake_up() is called, while in epoll() there are two queues.
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 13 lines · Evgeniy Polyakov
I probably selected wrong words to desribe, here is in details how kevent differs from epoll.
Polling case need to perform additional check before event can be copied to userspace, that check must be done for each even being copied. Kevent does not need that (it needs it for poll emulation) - if event is ready, then it is ready.
sys_poll()create a wait queue where different events (callbacks for them) are stored, when driver callswake_up()appropriate event is added to the ready list and callswake_up()for that wait queue, which in turn calls ->poll for each event and transfer it to userspace if it is ready.
Quoted 6 lines
Kevent works slightly different - it does not perform additional check for readiness (although it can, and it does in poll notifications), if event is marked as ready, parked in waiting syscal thread is awakened and event is copied to userspace.
Also waiting syscall is awakened through one queue - event is added andwake_up()is called, while inepoll()there are two queues.
Thank you Evgeniy for this comparison. poll()/select()/epoll() are tricky indeed.
I believe one advantage of epoll is it uses standard mechanism (mandated for poll()/select() ), while kevent adds some glue and kevent_storage in some structures (struct inode, struct file, ...), thus adding some extra code and extra storage in hot paths. Yes there might be a gain IF most users of these path want kevent. But other users pay the price (larger kernel code and data), that you cannot easily bench.
Using or not epoll has nearly zero cost over standard kernel (only struct file has some extra storage)
Quoted 9 lines · Eric Dumazet
I believe one advantage of epoll is it uses standard mechanism (mandated for poll()/select() ), while kevent adds some glue and
kevent_storagein some structures (struct inode, struct file, ...), thus adding some extra code and extra storage in hot paths. Yes there might be a gain IF most users of these path want kevent. But other users pay the price (larger kernel code and data), that you cannot easily bench.Using or not epoll has nearly zero cost over standard kernel (only struct file has some extra storage)
Well, that's a price - any event which wants to be supported needs to store for events - kevent_storage is a list_head plus spinlock and pointer to itself (with all current users that pointer can be removed and access transferred to container_of()) - it is exactly as in epoll storage - both were created with the smallest possible overhead in mind.
Signature · 1 line
Evgeniy Polyakov
Quoted 7 lines · Evgeniy Polyakov
I probably selected wrong words to desribe, here is in details how kevent differs from epoll.
Polling case need to perform additional check before event can be copied to userspace, that check must be done for each even being copied. Kevent does not need that (it needs it for poll emulation) - if event is ready, then it is ready.
That could be changed too. The "void *key" doesn't need to be NULL. Wake ups to f_op->poll() waiters can use that to send ready events directly, avoiding an extra f_op->poll() to fetch them.
Infrastructure is already there, just need a big patch to do it everywhere ;)
Quoted 6 lines
Kevent works slightly different - it does not perform additional check for readiness (although it can, and it does in poll notifications), if event is marked as ready, parked in waiting syscal thread is awakened and event is copied to userspace.
Also waiting syscall is awakened through one queue - event is added andwake_up()is called, while inepoll()there are two queues.
The really ancient version of epoll (called /dev/epoll at that time) was doing a very similar thing. Was adding custom plugs is all over the places where we wanted to get events from, and was collecting them w/out resorting to extra f_op->poll(). Event masks going straight through an event buffer.
The reason why the current design of epoll was chosen, was because:
o Was not requiring custom plus all over the places
o Was working with the current kernel abstractions as-is (though f_op->poll)
- Davide
Quoted 2 lines · Evgeniy Polyakov
Why userspace rescheduling is in order of tens times faster than kernel/user?
About 50 times in my Opteron 254 actually. That's libpcl's (swapcontext based) cobench against lat_ctx.
- Davide
Quoted 3 lines · Ingo Molnar
Fundamentally a kernel thread is just its
EIP/ESP [on x86, similar on other architectures] - which can be saved/restored in near zero time.
That's because the kernel address space is identical in every process's MMU context, so the MMU doesn't have to be touched _at_all_. Also, the kernel very rarely touches FPU state, and even when it does, the FXSAVE/FXRSTOR pair is highly optimized for the "save state just long enough to move some memory around with XMM instructions" case. (I know you know this; this is for the benefit of less experienced readers.) If your threadlet model shares the FPU state and TLS arena among all threadlets running on the same CPU, and threadlets are scheduled in bursts belonging to the same process (and preferably the same threadlet entrypoint), then you will get similarly efficient userspace threadlet-to-threadlet transitions. If not, not.
Quoted 5 lines
scheduling only relates to the minimal context that is in the CPU. And most of that context we save upon /every system call entry/, and restore it upon every system call return. If it's so expensive to manipulate, why can the Linux kernel do a full system call in ~150 cycles? That's cheaper than the access latency to a single DRAM page.
That would be the magic of shadow register files. When the software does things that hardware expects it to do, everybody wins. When the software tries to get clever based on micro-benchmarks, everybody loses.
Cheers,
- Michael
Quoted 7 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by
tcp_sendmsg()for slow clients - rescheduling will kill a machine.
Quoted 8 lines
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM - that's acceptable.)
At what point are the cachemiss threads destroyed ? In other words how well does this adapt to load variations ? For example, would this 80MB of RAM continue to be locked down even during periods of lighter loads thereafter ?
Regards
Suparna
Quoted 15 lines
Quoted 4 lines
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.yeah. Note that you can have a million sleeping threads if you want, the scheduler wont care. What matters more is the amount of true concurrency that is present at any given time. But yes, i agree that overscheduling can be a problem.
btw., what is the measurement utility you are using with kevents ('ab' perhaps, with a high -c concurrency count?), and which webserver are you using? (light-httpd?)
Ingo
Signature · 3 lines
Suparna Bhattacharya ([email protected]) Linux Technology Center IBM Software Lab, India
Quoted 10 lines · Suparna Bhattacharya
Quoted 9 lines
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM
- that's acceptable.)
Quoted 4 lines
At what point are the cachemiss threads destroyed ? In other words how well does this adapt to load variations ? For example, would this 80MB of RAM continue to be locked down even during periods of lighter loads thereafter ?
you can destroy them at will from user-space too - just start a slow timer that zaps them if load goes down. I can add a sys_async_thread_exit(nr_threads) API to be able to drive this without knowing the TIDs of those threads, and/or i can add a kernel-internal mechanism to zap inactive threads. It would be rather easy and low-overhead - the v2 code already had a max_nr_threads tunable, i can reintroduce it. So the size of the pool of contexts does not have to be permanent at all.
Ingo
Quoted 18 lines · Ingo Molnar
Quoted 10 lines · Suparna Bhattacharya
Quoted 9 lines
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM
- that's acceptable.)Quoted 4 lines
At what point are the cachemiss threads destroyed ? In other words how well does this adapt to load variations ? For example, would this 80MB of RAM continue to be locked down even during periods of lighter loads thereafter ?
Quoted 8 lines
you can destroy them at will from user-space too - just start a slow timer that zaps them if load goes down. I can add a
sys_async_thread_exit(nr_threads)API to be able to drive this without knowing the TIDs of those threads, and/or i can add a kernel-internal mechanism to zap inactive threads. It would be rather easy and low-overhead - the v2 code already had amax_nr_threadstunable, i can reintroduce it. So the size of the pool of contexts does not have to be permanent at all.
If you can find a way to do this without additional tunables burden on the administrator that would certainly help ! IIRC, performance problems linked to having too many or too few AIO kernel threads has been a commonly reported issue elsewhere - it would be nice to be able to avoid repeating the crux of that (mistake) in Linux. To me, any need to manually tune the number has always seemed to defeat the very benefit of adaptability of varying loads that AIO intrinsically provides.
Regards
Suparna
Quoted 2 lines
Ingo
Signature · 3 lines
Suparna Bhattacharya ([email protected]) Linux Technology Center IBM Software Lab, India
Quoted 4 lines · Ingo Molnar
Quoted 3 lines
It is not a TUX anymore - you had 1024 threads, and all of them will be consumed by
tcp_sendmsg()for slow clients - rescheduling will kill a machine.
Quoted 8 lines
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM - that's acceptable.)
This is a fundamental misconception. The state machine doesn't have to do anything but chase pointers through cache. Done right, it hardly even branches (although the branch misprediction penalty is a lot less of a worry on current x86_64 than it was in the mega-superscalar-out-of-order-speculative-execution days). It's damn near free -- but it's a pain in the butt to code, and it has to be done either in-kernel or in per-CPU OS-atop-the-OS dispatch threads.
The scheduler, on the other hand, has to blow and reload all of the hidden state associated with force-loading the PC and wherever your architecture keeps its TLS (maybe not the whole TLB, but not nothing, either). The only way around this that I can think of is to make threadlets promise that they will not touch anything thread-local, and that when the FPU is handed to them in a specific, known state, they leave it in that same state. (Some of the flags can be unspecified-but-don't-touch-me.) Then you can schedule threadlets in bursts with negligible transition cost from one to the next.
There is, however, a substantial setup cost for a burst, because you have to put the FPU in that known state and lock out TLS access (this is user code, after all). If the wrong process is in foreground, you also need to switch process context at the start of a burst; no fandangos on other processes' core, please, and to be remotely useful the threadlets need access to process-global data structures and synchronization primitives anyway. That's why you need for threadlets to have a separate SCHED_THREADLET priority and at least a weak ordering by PID. At which point you are outside the feature set of the O(1) scheduler as I understand it, and you might as well schedule them from the next tasklet following the softirq dispatcher.
Quoted 8 lines
Quoted 3 lines
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.yeah. Note that you can have a million sleeping threads if you want, the scheduler wont care. What matters more is the amount of true concurrency that is present at any given time. But yes, i agree that overscheduling can be a problem.
What matters is that a burst of I/O responses be scheduled efficiently without taking down the rest of the box. That, and the ability to cancel no-longer-interesting I/O requests in bulk, without leaking memory and synchronization primitives all over the place. If you don't have that, this scheme is UNUSABLE for network I/O.
Quoted 3 lines
btw., what is the measurement utility you are using with kevents ('ab' perhaps, with a high -c concurrency count?), and which webserver are you using? (light-httpd?)
Do me a favor. Do some floating point math and a memcpy() in between syscalls in the threadlet. Actually fiddle with errno and the FPU rounding flags. Watch it slow to a crawl and/or break floating point arithmetic horribly. Understand why no one with half a brain uses Java, or any other language which cuts FP corners for the sake of cheap threads, for calculations that have to be correct. (Note that Kahan received the Turing award for contributions to IEEE 754. If his polemic is too thick, read
http://www-128.ibm.com/developerworks/java/library/j-jtp0114/.)
Cheers,
- Michael
Quoted 4 lines
to do anything but chase pointers through cache. Done right, it hardly even branches (although the branch misprediction penalty is a lot less of a worry on current
x86_64than it was in the mega-superscalar-out-of-order-speculative-execution days). It's damn
Actually it costs a lot more on at least one vendors processor because you stall very long pipelines.
Quoted 3 lines
threadlets promise that they will not touch anything thread-local, and that when the FPU is handed to them in a specific, known state, they leave it in that same state. (Some of the flags can be
We don't use the FPU in the kernel except in very weird cases where it makes an enormous performance difference. The threadlets also have the same page tables so they have the same %cr3 so its very cheap to switch, basically a predicted jump and some register loads
Quoted 2 lines
Do me a favor. Do some floating point math and a
memcpy()in between syscalls in the threadlet. Actually fiddle with errno and the FPU
We don't have an errno in the kernel because its a stupid idea. Errno is a user space hack for compatibility with 1970's bad design. So its not relevant either.
Alan
Quoted 7 lines · Alan
Quoted 4 lines
to do anything but chase pointers through cache. Done right, it hardly even branches (although the branch misprediction penalty is a lot less of a worry on current
x86_64than it was in the mega-superscalar-out-of-order-speculative-execution days). It's damnActually it costs a lot more on at least one vendors processor because you stall very long pipelines.
You're right; I overreached there. I haven't measured branch misprediction penalties in dog's years (I focus more on system latency issues these days), so I'm just going on rumor. If your CPU vendor is still playing the tune-for-SpecINT-at-the-expense-of-real-code game (*cough* Itanic *cough*), get another CPU vendor -- while you still can.
Quoted 8 lines
Quoted 3 lines
threadlets promise that they will not touch anything thread-local, and that when the FPU is handed to them in a specific, known state, they leave it in that same state. (Some of the flags can be
We don't use the FPU in the kernel except in very weird cases where it makes an enormous performance difference. The threadlets also have the same page tables so they have the same %cr3 so its very cheap to switch, basically a predicted jump and some register loads
Do you not understand that real user code touches FPU state at unpredictable (to the kernel) junctures? Maybe not in a database or a web server, but in the GUIs and web-based monitoring applications that are 99% of the potential customers for kernel AIO? I have no idea what a %cr3 is, but if you don't fence off thread-local stuff from the threadlets you are just begging for end-user Heisenbugs and a place in the dustheap of history next to Symbolics LISP.
Quoted 6 lines
Quoted 2 lines
Do me a favor. Do some floating point math and a
memcpy()in between syscalls in the threadlet. Actually fiddle with errno and the FPUWe don't have an errno in the kernel because its a stupid idea. Errno is a user space hack for compatibility with 1970's bad design. So its not relevant either.
Dude, it's thread-local, and the glibc wrapper around most synchronous syscalls touches it. If you don't instantiate a new TLS context (or whatever the right lingo for that is) for every threadlet, you are TOAST -- if you let the user call stuff out of <stdlib.h> (let alone <stdio.h>) from within the threadlet.
Cheers,
- Michael
OK, having skimmed through Ingo's code once now, I can already see I have some crow to eat. But I still have some marginally less stupid questions.
Cachemiss threads are created with CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_THREAD | CLONE_SYSVSEM. Does that mean they share thread-local storage with the userspace thread, have thread-local storage of their own, or have no thread-local storage until NPTL asks for it?
When the kernel zeroes the userspace stack pointer in cachemiss_thread(), presumably the allocation of a new userspace stack page is postponed until that thread needs to resume userspace execution (after completion of the first I/O that missed cache). When do you copy the contents of the threadlet function's stack frame into this new stack page?
Is there anything in a struct pt_regs that is expensive to restore (perhaps because it flushes a pipeline or cache that wasn't already flushed on syscall entry)? Is there any reason why the FPU context has to differ among threadlets that have blocked while executing the same userspace function with different stacks? If the TLS pointer isn't in either of these, where is it, and why doesn't move_user_context() swap it?
If you set out to cancel one of these threadlets, how are you going to ensure that it isn't holding any locks? Is there any reasonable way to implement a userland finally { } block so that you can release malloc'd memory and clean up application data structures?
If you want to migrate a threadlet to another CPU on syscall entry and/or exit, what has to travel other than the userspace stack and the struct pt_regs? (I am assuming a quiesced FPU and thread(s) at the destination with compatible FPU flags.) Does it make sense for the userspace stack page to have space reserved for a struct pt_regs before the threadlet stack frame, so that the entire userspace threadlet state migrates as one page?
I now see that an effort is already made to schedule threadlets in bursts, grouped by PID, when several have unblocked since the last timeslice. What is the transition cost from one threadlet to another? Can that transition cost be made lower by reducing the amount of state that belongs to the individual threadlet vs. the pool of cachemiss threads associated with that threadlet entrypoint?
Generally, is there a "contract" that could be made between the threadlet application programmer and the implementation which would allow, perhaps in future hardware, the kind of invisible pipelined coprocessing for AIO that has been so successful for FP?
I apologize for having adopted a hostile tone in a couple of previous messages in this thread; remind me in the future not to alternate between thinking about code and about the FSF. :-) I do really like a lot of things about the threadlet model, and would rather not see it given up on for network I/O and NUMA systems. So I'm going to reiterate again -- more politely this time -- the need for a data-structure-centric threadlet pool abstraction that supports request throttling, reprioritization, bulk cancellation, and migration of individual threadlets to the node nearest the relevant I/O port.
I'm still not sold on syslets as anything userspace-visible, but I could imagine them enabling a sort of functional syntax for chaining I/O operations, with most failures handled as inline "Not-a-Pointer" values or as "AEIOU" (asynchronously executed I/O unit?) exceptions instead of syscall-test-branch-syscall-test-branch. Actually working out the semantics and getting them adopted as an IEEE standard could even win someone a Turing award. :-)
Cheers,
- Michael
Quoted 7 lines · Michael K. Edwards
Quoted 4 lines · Alan
We don't use the FPU in the kernel except in very weird cases where it makes an enormous performance difference. The threadlets also have the same page tables so they have the same %cr3 so its very cheap to switch, basically a predicted jump and some register loads
Quoted 5 lines
Do you not understand that real user code touches FPU state at unpredictable (to the kernel) junctures? Maybe not in a database or a web server, but in the GUIs and web-based monitoring applications that are 99% of the potential customers for kernel AIO?
I have no idea what a %cr3 is, [...]
then please stop wasting Alan's time ...
Ingo
Quoted 2 lines
Do you not understand that real user code touches FPU state at unpredictable (to the kernel) junctures? Maybe not in a database or a
We don't care. We don't have to care. The kernel threadlets don't execute in user space and don't do FP.
Quoted 3 lines
web server, but in the GUIs and web-based monitoring applications that are 99% of the potential customers for kernel AIO? I have no idea what a %cr3 is, but if you don't fence off thread-local stuff from the
How about you go read the intel architecture manuals then you might know more.
Quoted 5 lines
Quoted 3 lines
We don't have an errno in the kernel because its a stupid idea. Errno is a user space hack for compatibility with 1970's bad design. So its not relevant either.
Dude, it's thread-local, and the glibc wrapper around most synchronous
Last time I checked glibc was in userspace and the interface for kernel AIO is a matter for the kernel so errno is irrelevant, plus any threadlets doing system calls will only be living in kernel space anyway.
Quoted 5 lines · Alan
Quoted 2 lines
Do you not understand that real user code touches FPU state at unpredictable (to the kernel) junctures? Maybe not in a database or a
We don't care. We don't have to care. The kernel threadlets don't execute in user space and don't do FP.
Blocked threadlets go back out to userspace, as new threads, after the first blocking syscall completes. That's how Ingo described them in plain English, that's how his threadlet example would have to work, and that appears to be what his patches actually do.
Quoted 6 lines
Quoted 3 lines
web server, but in the GUIs and web-based monitoring applications that are 99% of the potential customers for kernel AIO? I have no idea what a %cr3 is, but if you don't fence off thread-local stuff from the
How about you go read the intel architecture manuals then you might know more.
Y'know, there's more to life than x86. I'm no MMU expert, but I know enough about ARM TLS and ptrace to have fixed ltrace -- not that that took any special wizardry, just a need for it to work and some basic forensic skill. If you want me to go away completely or not follow up henceforth on anything you write, say so, and I'll decide what to do in response. Otherwise, you might consider evaluating whether there's a way to interpret my comments so that they reflect a perspective that does not overlap 100% with yours rather than total idiocy.
Quoted 3 lines
Last time I checked glibc was in userspace and the interface for kernel AIO is a matter for the kernel so errno is irrelevant, plus any threadlets doing system calls will only be living in kernel space anyway.
Ingo's original example code:
long my_threadlet_fn(void *data)
{
char *name = data;
int fd;
fd = open(name, O_RDONLY);
if (fd < 0)
goto out;
fstat(fd, &stat);
read(fd, buf, count)
...out:
return threadlet_complete(); }
You're telling me that runs entirely in kernel space when open() blocks, and doesn't touch errno if fstat() fails? Now who hasn't read the code?
Cheers,
- Michael
Quoted 13 lines
long
my_threadlet_fn(void *data){ char *name = data; int fd; fd = open(name, O_RDONLY); if (fd < 0) goto out; fstat(fd, &stat); read(fd, buf, count) ...
Quoted 7 lines
out:
return threadlet_complete(); }You're telling me that runs entirely in kernel space when
open()blocks, and doesn't touch errno iffstat()fails? Now who hasn't read the code?
That example touches back into user space, but doesnt involve MMU changes or cache flushes, or tlb flushes, or floating point.
errno is thread specific if you use it but errno is as I said before entirely a C library detail that you don't have to suffer if you don't want to. Avoiding that saves a segment register load - which isn't too costly but isn't free.
Alan
Thanks for taking me at least minimally seriously, Alan. Pretty generous of you, all things considered.
Quoted 2 lines · Alan
That example touches back into user space, but doesnt involve MMU changes or cache flushes, or tlb flushes, or floating point.
True -- on an architecture where a change of TLS does not substantially affect the TLB and cache, which (AIUI) it does on most or all ARMs. (On a pre-EABI ARM, there is even a substantial cache-related penalty for encoding the syscall number in the syscall opcode, because you have to peek back at the text segment to see it, which costs you a D-cache stall.) Now put an sprintf with a %d in it between a couple of the syscalls, and _your_ arch is hurting. Deny the userspace programmer the use of the FPU in threadlets, and they become a lot less widely applicable -- and a lot flakier in a non-wizard's hands, given that people often cheat around the small number of x86 integer registers by using FP registers when copying memory in bulk.
Quoted 4 lines
errno is thread specific if you use it but errno is as I said before entirely a C library detail that you don't have to suffer if you don't want to. Avoiding that saves a segment register load - which isn't too costly but isn't free.
On your arch, it's a segment register -- and another who-knows-how-many pages to migrate along with the stack and pt_regs. On ARM, it's a coprocessor register that is incorrectly emulated by most JTAG emulators (so bye-bye JTAG-assisted debugging and profiling), or possibly a register stolen from the general purpose register set. On some MIPSes I have known you probably can't implement TLS safely without a cache flush.
If you tell people up front not to touch TLS in threadlets -- which means not to use routines from <stdlib.h> and <stdio.h> -- then implementors may have enough flexibility to make them perform well on a wide range of architectures. Alternately, if there are some things that threadlet users will genuinely need TLS for, you can tell them that all of the threadlets belonging to process X on CPU Y share a TLS context, and therefore things like errno can't be trusted across a syscall -- but then you had better make fairly sure that threadlets aren't preempted by other threadlets in between syscalls. Similar arguments apply to FPU state.
IEEE 754. Harp, harp. :-)
Cheers,
- Michael
Quoted 4 lines · I wrote:
(On a pre-EABI ARM, there is even a substantial cache-related penalty for encoding the syscall number in the syscall opcode, because you have to peek back at the text segment to see it, which costs you a D-cache stall.)
Before you say it, I'm aware that this is not directly relevant to TLS switch costs, except insofar as the "arch-dependent syscalls" introduced for certain parts of ARM TLS handling carry the same overhead as any other syscall. My point is that the system impact of seemingly benign operations is not always predictable even to the arch experts, and therefore one should be "parsimonious" (to use Kahan's word) in defining what semantics programmers may rely on in performance-critical situations.
If you arrange things so that threadlets are scheduled as much as possible in bursts that share the same processor context (process context, location in program text, TLS arena, FPU state -- basically everything other than stack and integer registers), you are giving yourself and future designers the maximum opportunity for exploiting hardware optimizations. This would be a good thing if you want threadlets to be performance-competitive with state machine designs.
If you still allow application programmers to _use_ shared processor state, in the knowledge that it will be clobbered on threadlet switch, then threadlets can use most of the coding style with which programmers of event-driven frameworks are familiar. This would be a good thing if you want threadlets to get wider use than the innards of three or four databases and web servers.
Cheers,
- Michael
Quoted 2 lines · Michael K. Edwards
which costs you a D-cache stall.) Now put an sprintf with a %d in it between a couple of the syscalls, and _your_ arch is hurting. ...
er, that would be a %f. :-)
Cheers,
- Michael
Quoted 12 lines · Michael K. Edwards
Quoted 9 lines · Ingo Molnar
maybe it will, maybe it wont. Lets try? There is no true difference between having a 'request structure' that represents the current state of the HTTP connection plus a statemachine that moves that request between various queues, and a 'kernel stack' that goes in and out of runnable state and carries its processing state in its stack - other than the amount of RAM they take. (the kernel stack is 4K at a minimum - so with a million outstanding requests they would use up 4 GB of RAM. With 20k outstanding requests it's 80 MB of RAM
- that's acceptable.)
Quoted 6 lines
This is a fundamental misconception. [...]
The scheduler, on the other hand, has to blow and reload all of the hidden state associated with force-loading the PC and wherever your architecture keeps its TLS (maybe not the whole TLB, but not nothing, either). [...]
please read up a bit more about how the Linux scheduler works. Maybe even read the code if in doubt? In any case, please direct kernel newbie questions to http://kernelnewbies.org/, not [email protected].
Ingo
Quoted 10 lines · Ingo Molnar
Quoted 6 lines
This is a fundamental misconception. [...]
The scheduler, on the other hand, has to blow and reload all of the hidden state associated with force-loading the PC and wherever your architecture keeps its TLS (maybe not the whole TLB, but not nothing, either). [...]
please read up a bit more about how the Linux scheduler works. Maybe even read the code if in doubt? In any case, please direct kernel newbie questions to http://kernelnewbies.org/, not [email protected].
This is not the first kernel I've swum around in, and I've been mucking with the Linux kernel since early 2.2 and coding assembly for heavily pipelined processors on and off since 1990. So I may be a newbie to your lingo, and I may even be a loud-mouthed idiot, but I'm not a wet-behind-the-ears undergrad, OK?
Now, I've addressed the non-free-ness of a TLS swap elsewhere; what about function pointers in state machines (with or without flipping "supervisor mode" bits)? Just because loading the PC from a data register is one opcode in the instruction stream does not mean that it is not quite expensive in terms of blown pipeline state and I-cache stalls. Really fast state machines exploit PC-relative branches that really smart CPUs can speculatively execute past (after a few traversals) because there are a small number of branch targets actually hit. The instruction prefetch / scheduler unit actually keeps a table of PC-relative jump instructions found in I-cache, with a little histogram of destinations eventually branched to, and speculatively executes down the top branch or two. (Intel Pentiums have a fairly primitive but effective variant of this; see
http://www.x86.org/articles/branch/branchprediction.htm.)
More general mechanisms are called "branch target buffers" and US Patent 6609194 is a good hook into the literature. A sufficiently smart CPU designer may have figured out how to do something similar with computed jumps (add pc, pc, foo), but odds are high that it cuts out when you throw function pointers around. Syscall dispatch is a special and heavily optimized case, though -- so it's quite conceivable that a well designed userland switch/case state machine that makes syscalls will outperform an in-kernel state machine data structure traversal. If this doesn't happen to be true on today's desktop, it may be on tomorrow's desktop or today's NUMA monstrosity or embedded mega-multi-MIPS.
There can also be other reasons why tabulated PC-relative jumps and immediate PC loads are faster than PC loads from data registers. Take, for instance, the Transmeta Crusoe, which (AIUI) used a trick similar to the FX!32 x86 emulation on Alpha/NT. If you're going to "translate" CISC to RISC on the fly, you're going to recognize switch/case idioms (including tabulated PC-relative branches), and fix up the translated branch table to contain offsets to the RISC-translated branch targets. So the state transitions are just as cheap as if they had been compiled to RISC in the first place. Do it with function pointers, and the the execution machine is going to have to stall while it looks up the text location to see if it has it translated in I-cache somewhere. Guess what: the PIV works the same way (http://www.karbosguide.com/books/pcarchitecture/chapter12.htm).
Are you starting to get the picture that syslets -- clever as they might have been on a VAX -- defeat many of the mechanisms that CPU and compiler architects have negotiated over decades for accelerating real code? Especially now that we have hyper-threaded CPUs (parallel instruction decode/issue units sharing almost all of their cache hierarchy), you can almost treat the kernel as if it were microcode for a syscall coprocessor. If you try to migrate application code across the syscall boundary, you may perform well on micro-benchmarks but you're storing up trouble for the future.
If you don't think this kind of fallout is real, talk to whoever had the bright idea of hijacking FPU registers to implement memcpy in 1996. The PIII designers rolled over and added XMM so micro-optimizers would get their dirty mitts off the FPU, which it appears that Doug Ledford and Jim Blandy duly acted on in 1999. Yes, you still need to use FXSAVE/FXRSTOR when you want to mess with the XMM stuff, but the CPU is smart enough to keep a shadow copy of all the microstate that the flag states represent. So if all you do between FXSAVE and FXRSTOR is shlep bytes around with MOVAPS, the FXRSTOR costs you little or nothing. What hurts is an FXRSTOR from a location that isn't the last location you FXSAVEd to, or an FXRSTOR after actual FP arithmetic instructions have altered status flags.
The preceding may contain errors in detail -- I am neither a CPU architect nor an x86 compiler writer nor even a serious kernel hacker. But hopefully it's at least food for thought. If not, you know where the "ignore this prolix nitwit" key is to be found on your keyboard.
Cheers,
- Michael
Quoted 2 lines · Michael K. Edwards
The preceding may contain errors in detail -- I am neither a CPU architect nor an x86 compiler writer nor even a serious kernel hacker.
Ok, roger that. But why are you playing "Google & Preach" games to Ingo, that ate bread and CPUs for the last 15 years?
- Davide
Quoted 2 lines · Davide Libenzi
Ok, roger that. But why are you playing "Google & Preach" games to Ingo, that ate bread and CPUs for the last 15 years?
Sure I used Google -- for clickable references so that lurkers can tell I'm not making these things up as I go along. Ingo and Alan have obviously forgotten more about x86en than I will ever know, and I'm carrying coals to Newcastle when I comment on pros and cons of XMM memcpy.
But although the latest edition of the threadlet patches actually has quite good internal documentation and makes most of its intent clear even to a reader (me) who is unfamiliar with the code being patched, it lacks "theory of operations". How is an arch maintainer supposed to adapt this interface to a completely different CPU, with different stuff in pt_regs and different cost profiles for blown pipelines and reloaded coprocessor state? What are the hidden costs of this particular style of M:N microthreading, and will they explode when this model escapes out of the microbenchmarks and people who don't know CPUs inside and out start using it? What standard thread-pool-management use cases are being glossed over at kernel level and left to Ulrich (or implementors of JVMs and other bytecode machines) to sort out?
At some level, I'm just along for the ride; nobody with any sense is going to pay me to design this sort of thing, and the level of effort involved in coding an alternate AIO implementation is not something I can afford to expend on non-revenue-producing activities even if I did have the skill. Maybe half of my quibbles are sheer stupidity and four out of five of the rest are things that Ingo has already taken account in v4 of his patch set. But that would leave one quibble in ten that has some substance, which might save some nasty rework down the line. Even if everything I ask about has a simple explanation, and for Alan and Ingo to waste time spelling it out for me would result in nothing but an accelerated "theory of operation" document, would that be a bad thing?
Now I know very little about x86_64 other than that 64-bit code not only has double-size integer registers to work with, it has twice as many of them. So for all I know the transition to pure-64-bit 2-4 core x 2-4 thread/core systems, which is going to be 90% or more of the revenue-generating Linux market over the next few years, makes all of my concerns moot for Ingo's purposes. After all, as long as Linux stays good enough to keep Oracle from losing confidence and switching to Darwin or something, the 100 or so people who earn invites to the kernel summit have cush jobs for life.
The rest of us would perhaps like for major proposed kernel overhauls to be accompanied by some kind of analysis of their impact on arches that live elsewhere in CPU parameter space. That analysis might suggest small design refinements that make Linux AIO scale well on the class of processors I'm interested, too. And I personally would like to see Ingo get that Turing award for designing AIO semantics that are as big an advance over the past as IEEE 754 was over its predecessors. He'd have to earn it, though.
Cheers,
- Michael
Quoted 4 lines · Evgeniy Polyakov
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.
Why do people *keep* taking this up as an issue?
Use select/poll/epoll/kevent/whatever for event mechanisms. STOP CLAIMING that you'd use threadlets/syslets/aio for that. It's been pointed out over and over and over again, and yet you continue to make the same mistake, Evgeniy.
So please read that sentence ten times, and then don't continue to make that same mistake. PLEASE.
Event mechanisms are *superior* for events. But they *suck* for things that aren't events, but are actual code execution with random places that can block. THE TWO THINGS ARE TOTALLY AND UTTERLY INDEPENDENT!
Examples of events:
- packet arrives
- timer happens
Examples of things that are *not* "events":
- filesystem lookup.
- page faults
So the basic point is: for events, you use an event-based thing. For code execution, you use a thread-based thing. It's really that simple.
And yes, the two different things can usually be translated (at a very high cost in complexity *and* performance) into each other, so people who look at it as purely a theoretical exercise may think that "events" and "code execution" are equivalent. That's a very very silly and stupid way of looking at things in real life, though.
Yes, you can turn things that are better seen as threaded execution into an event-based thing by turning it into a state machine. And usually that is a TOTAL DISASTER, and the end result is fragile and impossible to maintain.
And yes, you can often (more easily) turn an event-based mechanism into a thread-based one, and usually the end result is a TOTAL DISASTER because it doesn't scale very well, and while it may actually result in somewhat simpler code, the overhead of managing ten thousand outstanding threads is just too high, when you compare to managing just a list of ten thousand outstanding events.
And yes, people have done both of those mistakes. Java, for example, largely did the latter mistake ("we don't need anything like 'select', because we'll just use threads for everything" - what a totally moronic thing to do!)
So Evgeniy, threadlets/syslets/aio is *not* a replacement for event queues. It's a TOTALLY DIFFERENT MECHANISM, and one that is hugely superior to event queues for certain kinds of things. Anybody who thinks they want to do pathname and inode lookup as a series of events is likely a moron. It's really that simple.
In a complex server (say, a database), you'd use both. You'd probably use events for doing the things you *already* use events for (whether it be select/poll/epoll or whatever): probably things like the client network connection handling.
But you'd *in*addition* use threadlets to be able to do the actual database IO in a threaded manner, so that you can scale the things that are not easily handled as events (usually because they have internal kernel state that the user cannot even see, and *must*not* see because of security issues).
So please. Stop this "kevents are better". The only thing you show by trying to go down that avenue is that you don't understand the *difference* between an event model and a thread model. They are both perfectly fine models and they ARE NOT THE SAME! They aren't even mutually incompatible - quite the reverse.
The thing people want to remove with threadlets is the internal overhead of maintaining special-purpose code like aio_read() inside the kernel, that doesn't even do all that people want it to do, and that really does need a fair amount of internal complexity that we could hopefully do with a more generic (and hopefully *simpler*) model.
Linus
Quoted 11 lines · Linus Torvalds
Quoted 3 lines
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.Why do people *keep* taking this up as an issue?
Use select/poll/epoll/kevent/whatever for event mechanisms. STOP CLAIMING that you'd use threadlets/syslets/aio for that. It's been pointed out over and over and over again, and yet you continue to make the same mistake, Evgeniy.
Quoted 6 lines
So please read that sentence ten times, and then don't continue to make that same mistake. PLEASE.
Event mechanisms are *superior* for events. But they *suck* for things that aren't events, but are actual code execution with random places that can block. THE TWO THINGS ARE TOTALLY AND UTTERLY INDEPENDENT!
Note that even for something tasks are supposed to suck at, and even if used in extremely stupid ways, they perform reasonably well in practice ;-)
And i fully agree: specialization based on knowledge about frequency of blocking will always be useful - if not /forced/ on the workflow architecture and if not overdone. On the other hand, fully event-driven servers based on 'nonblocking' calls, which Evgeniy is advocating and which the kevent model is forcing upon userspace, is pure madness.
We very much can and should use things like epoll for events that we expect to happen asynchronously 100% of the time - it just makes no sense for those events to take up 4-5K of RAM apiece, when they could also be only using up the 32 bytes that say a pending timer takes. I've posted the code for that, how to do an 'outer' epoll loop around an internal threadlep iterator. But those will always be very narrow event sources, and likely wont (and shouldnt) cover 'request-internal' processing.
but otherwise, there is no real difference between a task that is scheduled and a request that is queued, 'other' than the size of the request (the task takes 4-5K of RAM), and the register context (64-128 bytes on most CPUs, the loading of which is optimized to death).
Which difference can still be significant for certain workloads, so we certainly dont want to prohibit specialized event interfaces and force generic threads on everything. But for anything that isnt a raw and natural external event source (time, network, disk, user-generated) there shouldnt be much of an event queueing abstraction i believe (other than what we get 'for free' within epoll, from having poll()-able files)
- and even for those event sources threadlets offer a pretty good run for the money.
one can always find the point and workload where say 40,000 threads start trashing the L2 cache, but where 40,000 queued special requests are still fully in cache, and produce spectacular numbers.
Ingo
Quoted 45 lines · Ingo Molnar
Quoted 11 lines · Linus Torvalds
Quoted 3 lines
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.Why do people *keep* taking this up as an issue?
Use select/poll/epoll/kevent/whatever for event mechanisms. STOP CLAIMING that you'd use threadlets/syslets/aio for that. It's been pointed out over and over and over again, and yet you continue to make the same mistake, Evgeniy.
Quoted 6 lines
So please read that sentence ten times, and then don't continue to make that same mistake. PLEASE.
Event mechanisms are *superior* for events. But they *suck* for things that aren't events, but are actual code execution with random places that can block. THE TWO THINGS ARE TOTALLY AND UTTERLY INDEPENDENT!
Note that even for something tasks are supposed to suck at, and even if used in extremely stupid ways, they perform reasonably well in practice ;-)
And i fully agree: specialization based on knowledge about frequency of blocking will always be useful - if not /forced/ on the workflow architecture and if not overdone. On the other hand, fully event-driven servers based on 'nonblocking' calls, which Evgeniy is advocating and which the kevent model is forcing upon userspace, is pure madness.
We very much can and should use things like epoll for events that we expect to happen asynchronously 100% of the time - it just makes no sense for those events to take up 4-5K of RAM apiece, when they could also be only using up the 32 bytes that say a pending timer takes. I've posted the code for that, how to do an 'outer' epoll loop around an internal threadlep iterator. But those will always be very narrow event sources, and likely wont (and shouldnt) cover 'request-internal' processing.
but otherwise, there is no real difference between a task that is scheduled and a request that is queued, 'other' than the size of the request (the task takes 4-5K of RAM), and the register context (64-128 bytes on most CPUs, the loading of which is optimized to death).
Quoted 8 lines
Which difference can still be significant for certain workloads, so we certainly dont want to prohibit specialized event interfaces and force generic threads on everything. But for anything that isnt a raw and natural external event source (time, network, disk, user-generated) there shouldnt be much of an event queueing abstraction i believe (other than what we get 'for free' within epoll, from having poll()-able files)
- and even for those event sources threadlets offer a pretty good run for the money.
I tend to agree.
Yes, some loads require event driven model, other can be done using threads. The only reason kevent was created is to allow to process any type of events in exaclty the same way in the same processing loop, it was optimized to have event register structure less than a cache line.
What I can not agree with, is that IO is a thread based stuff.
Quoted 5 lines
one can always find the point and workload where say 40,000 threads start trashing the L2 cache, but where 40,000 queued special requests are still fully in cache, and produce spectacular numbers.
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
I tend to agree.
Yes, some loads require event driven model, other can be done using threads.
event driven model is really complex though. For event driven to work well you basically can't tolerate blocking calls at all ... open() blocks on files. read() may block on metadata reads (say indirect blockgroups) not just on datareads etc etc. It gets really hairy really quick that way.
Signature · 2 lines
if you want to mail me at work (you don't), use arjan (at) linux.intel.com Test the interaction between Linux and your BIOS via http://www.linuxfirmwarekit.org
Quoted 11 lines · Arjan van de Ven
Quoted 3 lines · Evgeniy Polyakov
I tend to agree.
Yes, some loads require event driven model, other can be done using threads.event driven model is really complex though. For event driven to work well you basically can't tolerate blocking calls at all ...
open()blocks on files.read()may block on metadata reads (say indirect blockgroups) not just on datareads etc etc. It gets really hairy really quick that way.
I never ever tried to say _everything_ must be driven by events. IO must be driven, it is a must IMO.
Some (and a lot of) things can easily be programmed by threads. Threads are essentially for those tasks which can not be easily programmed with events.
But have in mind that fact, that thread execution _is_ an event itself, its completion is an event.
Quoted 3 lines
Signature · 2 lines
if you want to mail me at work (you don't), use arjan (at) linux.intel.com Test the interaction between Linux and your BIOS via http://www.linuxfirmwarekit.org
Signature · 1 line
Evgeniy Polyakov
Quoted 2 lines · Evgeniy Polyakov
I never ever tried to say _everything_ must be driven by events. IO must be driven, it is a must IMO.
Do you disagree with Linus' post about the difficulty of treating open(), fstat(), page faults, etc. as events? Or do you not consider them to be IO?
Chris
Quoted 10 lines · Chris Friesen
Quoted 2 lines · Evgeniy Polyakov
I never ever tried to say _everything_ must be driven by events. IO must be driven, it is a must IMO.
Do you disagree with Linus' post about the difficulty of treating
open(),fstat(), page faults, etc. as events? Or do you not consider them to be IO?From practical point of view - yes some of that processes are complex
enough to not attract attention as async usage model.
But I'm absolutely for the scenario, when several operations are performed asynchronously like open+stat+fadvice+sendfile.
By IO I meant something which has end result, and that result must be enough to start async processing - data in the buffer for example. Async open I would combine with actual data processing - that one can be a one event.
Quoted 1 line
Chris
Signature · 1 line
Evgeniy Polyakov
Quoted 9 lines · Linus Torvalds
Quoted 4 lines · Evgeniy Polyakov
My tests show that with 4k connections per second (8k concurrency) more than 20k connections of 80k total block in
tcp_sendmsg()over gigabit lan between quite fast machines.Why do people *keep* taking this up as an issue?
Let's warm our brains a little in this pseudo-technical word throwings :)
Quoted 16 lines
Use select/poll/epoll/kevent/whatever for event mechanisms. STOP CLAIMING that you'd use threadlets/syslets/aio for that. It's been pointed out over and over and over again, and yet you continue to make the same mistake, Evgeniy.
So please read that sentence ten times, and then don't continue to make that same mistake. PLEASE.
Event mechanisms are *superior* for events. But they *suck* for things that aren't events, but are actual code execution with random places that can block. THE TWO THINGS ARE TOTALLY AND UTTERLY INDEPENDENT!
Examples of events:
- packet arrives
- timer happens
Quoted 6 lines
Examples of things that are *not* "events":
- filesystem lookup.
- page faultsSo the basic point is: for events, you use an event-based thing. For code execution, you use a thread-based thing. It's really that simple.
Linus, you made your point clearly - generic AIO should not be used for the cases, when it is supposed to block 90% of the time - only when it almost never blocks, like in case of buffered IO.
Otherwise, when load nature requires almost always to block, we would see that each block is eventually removed - by something, which calls wake_up(), that something is an event, which we were supposed to wait, but instead we we resceduled and waited there, so we just added additional layer of dereferencing - we were scehduled away, did some work, then awakened, instead of doing some work and get event.
I do not even discuss, that micro-threading model is way tooo simpler to programm, but from above example is clear that it adds additional overhead, which in turn can be high or noticeble.
Quoted 18 lines
And yes, the two different things can usually be translated (at a very high cost in complexity *and* performance) into each other, so people who look at it as purely a theoretical exercise may think that "events" and "code execution" are equivalent. That's a very very silly and stupid way of looking at things in real life, though.
Yes, you can turn things that are better seen as threaded execution into an event-based thing by turning it into a state machine. And usually that is a TOTAL DISASTER, and the end result is fragile and impossible to maintain.
And yes, you can often (more easily) turn an event-based mechanism into a thread-based one, and usually the end result is a TOTAL DISASTER because it doesn't scale very well, and while it may actually result in somewhat simpler code, the overhead of managing ten thousand outstanding threads is just too high, when you compare to managing just a list of ten thousand outstanding events.
Quoted 4 lines
And yes, people have done both of those mistakes. Java, for example, largely did the latter mistake ("we don't need anything like 'select', because we'll just use threads for everything" - what a totally moronic thing to do!)
I can only say that I'm fully agree. Absolutely. No jokes.
Quoted 5 lines
So Evgeniy, threadlets/syslets/aio is *not* a replacement for event queues. It's a TOTALLY DIFFERENT MECHANISM, and one that is hugely superior to event queues for certain kinds of things. Anybody who thinks they want to do pathname and inode lookup as a series of events is likely a moron. It's really that simple.
Hmmm... let me describe that process a bit:
Userspace wants to open a file, so it needs some file-related (inode, direntry and others) structures in the mem, they should be read from disk. Eventually it will be reading some blocks from the disk (for example ext3_lookup->ext3_find_entry->ext3_getblk/ll_rw_block) and we will wait for them (wait_on_bit()) - we will wait for event.
But I agree, it was a brainfscking example, but nevertheless, it can be easily done using event driven model.
Reading from the disk is _exactly_ the same - the same waiting for buffer_heads/pages, and (since it is bigger) it can be easily transferred to event driven model.
Ugh, wait, it not only _can_ be transferred, it is already done in kevent AIO, and it shows faster speeds (though I only tested sending them over the net).
Quoted 10 lines
In a complex server (say, a database), you'd use both. You'd probably use events for doing the things you *already* use events for (whether it be select/poll/epoll or whatever): probably things like the client network connection handling.
But you'd *in*addition* use threadlets to be able to do the actual database IO in a threaded manner, so that you can scale the things that are not easily handled as events (usually because they have internal kernel state that the user cannot even see, and *must*not* see because of security issues).
Event is data readiness - no more, no less.
It has nothing with internal kernel structures - you just wait until data is ready in requested buffer (disk, net, whatever). Internal mechanism of moving data to the destination point can use event driven model too, but it is another question.
Eventually threads wait for the same events - but there is an additional overhead created to manage that objects called threads.
Ingo says that it is fast to manage them, but it can not be faster than properly created event driven abstraction, because, as you noticed himself, mutual transformations are complex.
Threadlets are simpler to program, but they do not add a gain compared to properly created singlethreaded model (or number of CPU-threadede model) with the right event processing mechanims.
Waiting for any IO is a waiting for event, other tasks can be made an event too, but I agree, it is simpler to use different models just because they already exist.
Quoted 11 lines
So please. Stop this "kevents are better". The only thing you show by trying to go down that avenue is that you don't understand the *difference* between an event model and a thread model. They are both perfectly fine models and they ARE NOT THE SAME! They aren't even mutually incompatible - quite the reverse.
The thing people want to remove with threadlets is the internal overhead of maintaining special-purpose code like
aio_read()inside the kernel, that doesn't even do all that people want it to do, and that really does need a fair amount of internal complexity that we could hopefully do with a more generic (and hopefully *simpler*) model.
Let me rephrase that stuff:
the thing people want to remove with linked lists is the internal overhead of maintaing special-purpose code like RB trees.
It sounds with similar part of idiocity in it.
If additional code provides faster processing, it must be used instead of fear of 'the internal overhead of maintaining special-purpose code'.
Quoted 1 line
Linus
Signature · 1 line
Evgeniy Polyakov
Quoted 4 lines · Evgeniy Polyakov
Linus, you made your point clearly - generic AIO should not be used for the cases, when it is supposed to block 90% of the time - only when it almost never blocks, like in case of buffered IO.
I don't think it's quite that simple.
EVEN *IF* it were to block 100% of the time, it depends on other things than just "blockingness".
For example, let's look at something like
fd = open(filename, O_RDONLY);
if (fd < 0)
return -1;
if (fstat(fd, &st) < 0) {
close(fd);
return -1;
}
.. do something ..and please realize that EVEN IF YOU KNOW WITH 100% CERTAINTY that the above open (or fstat()) is going to block, because you know that your working set is bigger than the available memory for caching, YOU SIMPLY CANNOT SANELY WRITE THAT AS AN EVENT-BASED STATE MACHINE!
It's really that simple. Some things block "in the middle". The reason UNIX made non-blocking reads available for networking, but not for filesystem accesses is not because one blocks and the other doesn't. No, it's really much more fundamental than that!
When you do a "recvmsg()", there is a clear event-based model: you can return -EAGAIN if the data simply isn't there, because a network connection is a simple stream of data, and there is a clear event on "ok, data arrived" without any state what-so-ever.
The same is simply not true for "open a file descriptor". There is no sane way to turn the "filename lookup blocked" into an event model with a select- or kevent-based interface.
Similarly, even for a simple "read()" on a filesystem, there is no way to just say "block until data is available" like there is for a socket, because on a filesystem, the data may be available, BUT AT THE WRONG OFFSET. So while a socket or a pipe are both simple "streaming interfaces" as far as a "read()" is concerned, a file access is *not* a simple streaming interface.
Notice? For a read()/recvmsg() call on a socket or a pipe, there is no "position" involved. The "event" is clear: it's always the head of the streaming interface that is relevant, and the event is "is there room" or "is there data". It's an event-based thing.
But for a read() on a file, it's no longer a streaming interface, and there is no longer a simple "is there data" event. You'd have to make the event be a much more complex "is there data at position X through Y" kind of thing.
And "read()" on a filesystem is the _simple_ case. Sure, we could add support for those kinds of ranges, and have an event interface for that. But the "open a filename" is much more complicated, and doesn't even have a file descriptor available to it (since we're trying to _create_ one), so you'd have to do something even more complex to have the event "that filename can now be opened without blocking".
See? Even if you could make those kinds of events, it would be absolutely HORRIBLE to code for. And it would suck horribly performance-wise for most code too.
THAT is what I'm saying. There's a *difference* between event-based and thread-based programming. It makes no sense to try to turn one into the other. But it often makes sense to *combine* the two approaches.
Quoted 9 lines
Userspace wants to open a file, so it needs some file-related (inode, direntry and others) structures in the mem, they should be read from disk. Eventually it will be reading some blocks from the disk (for example ext3_lookup->ext3_find_entry->ext3_getblk/ll_rw_block) and we will wait for them (
wait_on_bit()) - we will wait for event.But I agree, it was a brainfscking example, but nevertheless, it can be easily done using event driven model.
Quoted 6 lines
Reading from the disk is _exactly_ the same - the same waiting for buffer_heads/pages, and (since it is bigger) it can be easily transferred to event driven model.
Ugh, wait, it not only _can_ be transferred, it is already done in kevent AIO, and it shows faster speeds (though I only tested sending them over the net).
It would be absolutely horrible to program for. Try anything more complex than read/write (which is the simplest case, but even that is nasty).
Try imagining yourself in the shoes of a database server (or just about anything else). Imagine what kind of code you want to write. You probably do *not* want to have everything be one big event loop, and having to make different "states" for "I'm trying to open the file", "I opened the file, am now doing 'fstat()' to figure out how big it is", "I'm now reading the file and have read X bytes of the total Y bytes I want to read", "I took a page fault in the middle" etc etc.
I pretty much can *guarantee* you that you'll never see anybody do that. Page faults in user space are particularly hard to handle in a state machine, since they basically require saving the whole thread state, as they can happen on any random access. So yeah, you could do them as a state machine, but in reality it would just become a "user-level thread library" in the end, just to handle those.
In contrast, if you start using thread-like programming to begin with, you have none of those issues. Sure, some thread may block because you got a page fault, or because an inode needed to be brought into memory, but from a user-level programming interface standpoint, the thread library just takes care of the "state machine" on its own, so it's much simpler, and in the end more efficient.
And *THAT* is what I'm trying to say. Some simple obvious events are better handled and seen as "events" in user space. But other things are so intertwined, and have basically random state associated with them, that they are better seen as threads.
Yes, from a "turing machine" kind of viewpoint, the two are 100% logically equivalent. But "logical equivalence" does NOT translate into "can practically speaking be implemented".
Linus
Quoted 24 lines · Linus Torvalds
Similarly, even for a simple "
read()" on a filesystem, there is no way to just say "block until data is available" like there is for a socket, because on a filesystem, the data may be available, BUT AT THE WRONG OFFSET. So while a socket or a pipe are both simple "streaming interfaces" as far as a "read()" is concerned, a file access is *not* a simple streaming interface.Notice? For a read()/recvmsg() call on a socket or a pipe, there is no "position" involved. The "event" is clear: it's always the head of the streaming interface that is relevant, and the event is "is there room" or "is there data". It's an event-based thing.
But for a
read()on a file, it's no longer a streaming interface, and there is no longer a simple "is there data" event. You'd have to make the event be a much more complex "is there data at position X through Y" kind of thing.And "
read()" on a filesystem is the _simple_ case. Sure, we could add support for those kinds of ranges, and have an event interface for that. But the "open a filename" is much more complicated, and doesn't even have a file descriptor available to it (since we're trying to _create_ one), so you'd have to do something even more complex to have the event "that filename can now be opened without blocking".
Quoted 3 lines
See? Even if you could make those kinds of events, it would be absolutely HORRIBLE to code for. And it would suck horribly performance-wise for most code too.
I see our main discussion trouble I think.
I never ever tried to say, that every bit in read() should be non-blocking, it would be even more stupid than you expect it to be. But you and Ingo do not want to see, what I'm trying to say, because it is too cozy to read own right ideas than others.
I want to say, that read() consists of tons of events, but programmer needs only one - data is ready in requested buffer. Programmer might not even know what is the object behind provided file descriptor. One only wans data in the buffer.
That is an event.
It is also possible to have other events inside complex read() machinery
- for example waiting for page obtained via ->readpages().
Quoted 3 lines
THAT is what I'm saying. There's a *difference* between event-based and thread-based programming. It makes no sense to try to turn one into the other. But it often makes sense to *combine* the two approaches.
Thread is simple just because there is an interface. Change interface, and no one will ever want to do it.
Provide nice aio_read() (forget about posix) and everyone will use it.
I always said that combining of such models is a must, I fully agree, but it seems that we still do not agree where the bound should be drawn.
Quoted 41 lines
Quoted 9 lines
Userspace wants to open a file, so it needs some file-related (inode, direntry and others) structures in the mem, they should be read from disk. Eventually it will be reading some blocks from the disk (for example ext3_lookup->ext3_find_entry->ext3_getblk/ll_rw_block) and we will wait for them (
wait_on_bit()) - we will wait for event.But I agree, it was a brainfscking example, but nevertheless, it can be easily done using event driven model.
Quoted 6 lines
Reading from the disk is _exactly_ the same - the same waiting for buffer_heads/pages, and (since it is bigger) it can be easily transferred to event driven model.
Ugh, wait, it not only _can_ be transferred, it is already done in kevent AIO, and it shows faster speeds (though I only tested sending them over the net).It would be absolutely horrible to program for. Try anything more complex than read/write (which is the simplest case, but even that is nasty).
Try imagining yourself in the shoes of a database server (or just about anything else). Imagine what kind of code you want to write. You probably do *not* want to have everything be one big event loop, and having to make different "states" for "I'm trying to open the file", "I opened the file, am now doing '
fstat()' to figure out how big it is", "I'm now reading the file and have read X bytes of the total Y bytes I want to read", "I took a page fault in the middle" etc etc.I pretty much can *guarantee* you that you'll never see anybody do that. Page faults in user space are particularly hard to handle in a state machine, since they basically require saving the whole thread state, as they can happen on any random access. So yeah, you could do them as a state machine, but in reality it would just become a "user-level thread library" in the end, just to handle those.
In contrast, if you start using thread-like programming to begin with, you have none of those issues. Sure, some thread may block because you got a page fault, or because an inode needed to be brought into memory, but from a user-level programming interface standpoint, the thread library just takes care of the "state machine" on its own, so it's much simpler, and in the end more efficient.
Quoted 4 lines
And *THAT* is what I'm trying to say. Some simple obvious events are better handled and seen as "events" in user space. But other things are so intertwined, and have basically random state associated with them, that they are better seen as threads.
In threading you still need to do exactly the same, since stat() can not be done before open(). So you will maintain some state (actually order of things which will not be changed).
Have the same in the function.
Then start execution - it can be perfectly done using threads.
Just because it is unconvenient to program using state machines and there is no appropriate interface.
But there are another operations.
Consider database or whatever you like, which wants to read thousands of blocks from disk, each access potentially blocks, and blocking on the mutex is nothing compared to blocking on waiting for storage to be ready to provide data (network, disk, whatever). If storage is not optimized (or small cache, or something else) we end up with blocked contexts, which sleep - thousands of contexts.
And this number will not decrease.
So we ended with enourmous overhead just because we do not have simple enough aio_read() and aio_wait().
Quoted 3 lines
Yes, from a "turing machine" kind of viewpoint, the two are 100% logically equivalent. But "logical equivalence" does NOT translate into "can practically speaking be implemented".
You have said that finally!
"can practically speaking be implemented".
I see your and Ingo point - kevent is a 'merde' (pardon my french, but I even somehow glad Ingo said (almost) that - I now have plenty of time for other interesting projects), we want threads.
Ok, you have threads, but you need to wait on (some of) them.
So you will invent the wheel again - some subsystem which will wait for threads (likely waiting on futexes), then other events (probably). Eventually it will be the same from different point of view :)
Anyway, I _do_ hope we understood each other that both events and threads can co-exist, although board was not drawn.
My point is that many things can be done using event just because they are faster and smaller - and IO (any IO without limit) is one of the areas where it is unbeatable.
Threading in turn can be done a higher-layer abstraction model - thread can wrap around the whole transaction with all related data flows, but not thread per IO.
Quoted 1 line
Linus
Signature · 1 line
Evgeniy Polyakov
Quoted 5 lines · Evgeniy Polyakov
I want to say, that
read()consists of tons of events, but programmer needs only one - data is ready in requested buffer. Programmer might not even know what is the object behind provided file descriptor. One only wans data in the buffer.
You're not following the discussion.
First off, I already *told* you that "read()" is the absolute simplest case, and yes, we could make it an event if you also passed in the "which range of the file do we care about" information (we could consider it "f_pos", which the kernel already knows about, but that doesn't handle pread()/pwrite(), so it's not very good for many cases).
But that's not THE ISSUE.
The issue is that it's a horrible interface from a users standpoint. It's a lot better to program certain things as a thread. Why do you argue against that, when that is just obviously true.
There's a reason that people write code that is functional, rather than write code as a state machine.
We simply don't write code like
for (;;) {
switch (state) {
case Open:
fd = open();
if (fd < 0)
break;
state = Stat;
case Stat:
if (fstat(fd, &stat) < 0)
break;
state = Read;
case Read:
count = read(fd, buf + pos, size - pos));
if (count < 0)
break;
pos += count;
if (!count || pos == size)
state = Close;
continue;
case Close;
if (close(fd) < 0)
break;
state = Done;
return 0;
}
}
/* Returning 1 means wait in the event loop .. */
if (errno == EAGAIN || errno == EINTR)
return 1;
/* Else we had a real error */
state = Error;
return -1;and instead we write it as
fd = open(..)
if (fd < 0)
return -1;
if (fstat(fd, &st)) < 0) {
close(fd);
return -1;
}
.. and if you cannot see the *reason* why people don't use event-based programming for everything, I don't see the point of continuing this discussion.
See? Stop blathering about how everything is an event. THAT'S NOT RELEVANT. I've told you a hundred times - they may be "logically equivalent", but that doesn't change ANYTHING. Event-based programming simply isn't suitable for 99% of all stuff, and for the 1% where it *is* suitable, it actually tends to be a very specific subset of the code that you actually use events for (ie accept and read/write on pure streams).
Linus
Quoted 6 lines · Linus Torvalds
See? Stop blathering about how everything is an event. THAT'S NOT RELEVANT. I've told you a hundred times - they may be "logically equivalent", but that doesn't change ANYTHING. Event-based programming simply isn't suitable for 99% of all stuff, and for the 1% where it *is* suitable, it actually tends to be a very specific subset of the code that you actually use events for (ie accept and read/write on pure streams).
Will you argue that people do things like
num = epoll_wait()
for (i=0; i<num; ++i) {
process(event[i])?
}Will you spawn thread per IO?
Stop writing the same again and again - I perfectly understand that not everything can be easily covered by events, but covering everything with threads is more stupid idea.
High-performance IO requires as small as possible overhead, dispatching events from ring buffer or queue from each cpu is the smallest one, but not spawning a thread per read.
Quoted 1 line
Linus
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · Evgeniy Polyakov
Will you argue that people do things like
num =epoll_wait()for (i=0; i<num; ++i) { process(event[i])? }
I have several times told you that I argue for a *combination* of event-bassed interfaces and thread-like code. And that the choice depends on which is more natural. Sometimes you might have just one or the other. Sometimes you have both. And sometimes you have neither (although, strictly speaking, normal single-threaded code is certainly "thread-like"
- it's a serial execution, the same way threadlets are serial executions - it's just not running in parallel with anything else).
Quoted 1 line
Will you spawn thread per IO?
Depending on what the IO is, yes.
Is that _really_ so hard to understand? There is no "yes" or "no". There's a "depends on what the problem is, and what the solution looks like".
Sometimes the best way to do parallelism is through explicit threads. Sometimes it is through whatever "threadlets" or other that gets out of this whole development discussion. Sometimes it's an event loop.
So get over it. The world is not a black and white, either-or kind of place. It's full of grayscales, and colors, and mixing things appropriately. And the choices are often done on whims and on whatever feels most comfortable to the person doing the choice. Not on some strict "you must always use things in an event-driven main loop" or "you must always use threads for parallelism".
The world is simply _richer_ than that kind of either-or thing.
Linus
Quoted 29 lines · Linus Torvalds
Quoted 6 lines · Evgeniy Polyakov
Will you argue that people do things like
num =epoll_wait()for (i=0; i<num; ++i) { process(event[i])? }I have several times told you that I argue for a *combination* of event-bassed interfaces and thread-like code. And that the choice depends on which is more natural. Sometimes you might have just one or the other. Sometimes you have both. And sometimes you have neither (although, strictly speaking, normal single-threaded code is certainly "thread-like"
- it's a serial execution, the same way threadlets are serial executions - it's just not running in parallel with anything else).Quoted 1 line
Will you spawn thread per IO?
Depending on what the IO is, yes.
Is that _really_ so hard to understand? There is no "yes" or "no". There's a "depends on what the problem is, and what the solution looks like".
Sometimes the best way to do parallelism is through explicit threads. Sometimes it is through whatever "threadlets" or other that gets out of this whole development discussion. Sometimes it's an event loop.
Quoted 8 lines
So get over it. The world is not a black and white, either-or kind of place. It's full of grayscales, and colors, and mixing things appropriately. And the choices are often done on whims and on whatever feels most comfortable to the person doing the choice. Not on some strict "you must always use things in an event-driven main loop" or "you must always use threads for parallelism".
The world is simply _richer_ than that kind of either-or thing.
It seems you like to repeate that white is white and it is not black :) Did you see what I wrote in previous e-mail to you?
No, you do not.
I wrote that both model should co-exist, and boundary between the two is not clear, but for described workloads IMO event driven model provides way too higher performance.
That is it, Linus, no one wants to say that you say something stupid - just read what others write for you.
Thanks.
Quoted 1 line
Linus
Signature · 1 line
Evgeniy Polyakov
Quoted 9 lines · Linus Torvalds
Quoted 5 lines
Reading from the disk is _exactly_ the same - the same waiting for buffer_heads/pages, and (since it is bigger) it can be easily transferred to event driven model. Ugh, wait, it not only _can_ be transferred, it is already done in kevent AIO, and it shows faster speeds (though I only tested sending them over the net).
It would be absolutely horrible to program for. Try anything more complex than read/write (which is the simplest case, but even that is nasty).
note that even for something as 'simple and straightforward' as TCP sockets, the 25-50 lines of evserver code i worked on today had 3 separate bugs, is known to be fundamentally incorrect and one of the bugs (the lost event problem) showed up as a subtle epoll performance problem and it took me more than an hour to track down. And that matches my Tux experience as well: event based models are horribly hard to debug BECAUSE there is /no procedural state associated with requests/. Hence there is no real /proof of progress/. Not much to use for debugging - except huge logs of execution, which, if one is unlucky (which i often was with Tux) would just make the problem go away.
Furthermore, with a 'retry' model, who guarantees that the retry wont be an infinite retry where none of the retries ever progresses the state of the system enough to return the data we are interested in? The moment we have to /retry/, depending on the 'depth' of how deep the retry kicked in, we've got to reach that 'depth' of code again and execute it.
plus, 'there is not much state' is not even completely true to begin with, even in the most simple, TCP socket case! There /is/ quite a bit of state constructed on the kernel stack: user parameters have been evaluated/converted, the socket has been looked up, its state has been validated, etc. With a 'retry' model - but even with a pure 'event queueing' model we redo all those things /both/ at request submission and at event generation time, again and again - while with a synchronous syscall you do it just once and upon event completion a piece of that data is already on the kernel stack. I'd much rather spend time and effort on simplifying the scheduler and reducing the cache footprint of the kernel thread context switch path, etc., to make it more useful even in more extreme, highly prallel '100% context-switching' case, because i have first-hand experience about how fragile and inflexible event based servers are. I do think that event interfaces for raw, external physical events make sense in some circumstances, but for any more complex 'derived' event type it's less and less clear whether we want a direct interface to it. For something like the VFS it's outright horrible to even think about.
Ingo
Quoted 13 lines · Ingo Molnar
Quoted 9 lines · Linus Torvalds
Quoted 5 lines
Reading from the disk is _exactly_ the same - the same waiting for buffer_heads/pages, and (since it is bigger) it can be easily transferred to event driven model. Ugh, wait, it not only _can_ be transferred, it is already done in kevent AIO, and it shows faster speeds (though I only tested sending them over the net).
It would be absolutely horrible to program for. Try anything more complex than read/write (which is the simplest case, but even that is nasty).
Quoted 10 lines
note that even for something as 'simple and straightforward' as TCP sockets, the 25-50 lines of evserver code i worked on today had 3 separate bugs, is known to be fundamentally incorrect and one of the bugs (the lost event problem) showed up as a subtle epoll performance problem and it took me more than an hour to track down. And that matches my Tux experience as well: event based models are horribly hard to debug BECAUSE there is /no procedural state associated with requests/. Hence there is no real /proof of progress/. Not much to use for debugging - except huge logs of execution, which, if one is unlucky (which i often was with Tux) would just make the problem go away.
I'm glad you found a bug in my epoll processing code (which does not exist in kevent part though) - it took me more than a year after kevent introduction to make someone to look into.
Obviously there are bugs, it is simply how things work. And debugging state machine code has exactly the same complexity as debugging multi-threading code - if not less...
Quoted 16 lines
Furthermore, with a 'retry' model, who guarantees that the retry wont be an infinite retry where none of the retries ever progresses the state of the system enough to return the data we are interested in? The moment we have to /retry/, depending on the 'depth' of how deep the retry kicked in, we've got to reach that 'depth' of code again and execute it.
plus, 'there is not much state' is not even completely true to begin with, even in the most simple, TCP socket case! There /is/ quite a bit of state constructed on the kernel stack: user parameters have been evaluated/converted, the socket has been looked up, its state has been validated, etc. With a 'retry' model - but even with a pure 'event queueing' model we redo all those things /both/ at request submission and at event generation time, again and again - while with a synchronous syscall you do it just once and upon event completion a piece of that data is already on the kernel stack. I'd much rather spend time and effort on simplifying the scheduler and reducing the cache footprint of
Quoted 8 lines
the kernel thread context switch path, etc., to make it more useful even in more extreme, highly prallel '100% context-switching' case, because i have first-hand experience about how fragile and inflexible event based servers are. I do think that event interfaces for raw, external physical events make sense in some circumstances, but for any more complex 'derived' event type it's less and less clear whether we want a direct interface to it. For something like the VFS it's outright horrible to even think about.
Ingo, you draw too much black into the picture.
No one will crate purely event based model for socket or VFS processing
- event is completion of the request - data in the buffer, data was sent and so one - it is also possible to add events into middle of the processing especially if operation can be logically separated - like sendfile.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
Obviously there are bugs, it is simply how things work. And debugging state machine code has exactly the same complexity as debugging multi-threading code - if not less...
Evgeniy,
I think what you are not hearing, and what everyone else is saying (INCLUDING Linus), is that for most programmers, state machines are much, much harder to program, understand, and debug compared to multi-threaded code. You may disagree (were you a MacOS 9 programmer in another life?), and it may not even be true for you if you happen to be one of those folks more at home with Scheme continuations, for example. But it is true that for most kernel programmers, threaded programming is much easier to understand, and we need to engineer the kernel for what will be maintainable for the majority of the kernel development community.
Regards,
- Ted
Quoted 6 lines · Theodore Tso
Quoted 3 lines · Evgeniy Polyakov
Obviously there are bugs, it is simply how things work. And debugging state machine code has exactly the same complexity as debugging multi-threading code - if not less...
Evgeniy,
Hi Ted.
Quoted 10 lines
I think what you are not hearing, and what everyone else is saying (INCLUDING Linus), is that for most programmers, state machines are much, much harder to program, understand, and debug compared to multi-threaded code. You may disagree (were you a MacOS 9 programmer in another life?), and it may not even be true for you if you happen to be one of those folks more at home with Scheme continuations, for example. But it is true that for most kernel programmers, threaded programming is much easier to understand, and we need to engineer the kernel for what will be maintainable for the majority of the kernel development community.
I understand that - and I totally agree.
But when more complex, more bug-prone code results in higher performance
- that must be used. We have linked lists and binary trees - the latter are quite complex structures, but they allow to have higher performance in searching operatins, so we use them.
The same applies to state machines - yes, in some cases it is hard to program, but when things are already implemented and are wrapped into nice (no posix) aio_read(), there is absolutely no usage complexity.
Even if it is up to programmer to programm state machine based on generated events, that higher-layer state machines are not complex.
Let's get simple case of (aio_)read() from file descriptor - if page is in the cache, no readpage() method will be called, so we do not need to create some kind of events - just copy data, if there is no page or page is not uptodate, we allocate a bio and do not wait until buffers are read - we return to userspace and start another reading, when bio is completed and its end_io callback is called, we mark pages as uptodate, copy data to userspace, and mark event bound to above (aio_)read() as completed.
(that is how kevent aio works, btw).
Userspace programmer just calls
cookie = aio_read();aio_wait(cookie);
or something like that.
It is simple, it is straightforward, especially if data read must then be used somewhere else - in that case processing thread will need to operate with main one, which is simple in event model, since there is a place, where events of _all_ types are gathered.
Quoted 3 lines
Regards,
- Ted
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · Evgeniy Polyakov
Quoted 4 lines
[...] But it is true that for most kernel programmers, threaded programming is much easier to understand, and we need to engineer the kernel for what will be maintainable for the majority of the kernel development community.
I understand that - and I totally agree.
why did you then write, just one mail ago, the exact opposite:
Quoted 2 lines
And debugging state machine code has exactly the same complexity as debugging multi-threading code - if not less...
the kernel /IS/ multi-threaded code.
which statement of yours is also patently, absurdly untrue. Multithreaded code is harder to debug than process based code, but it is still a breeze compared to complex state-machines...
Ingo
Quoted 14 lines · Ingo Molnar
Quoted 6 lines · Evgeniy Polyakov
Quoted 4 lines
[...] But it is true that for most kernel programmers, threaded programming is much easier to understand, and we need to engineer the kernel for what will be maintainable for the majority of the kernel development community.
I understand that - and I totally agree.
why did you then write, just one mail ago, the exact opposite:
Quoted 2 lines
And debugging state machine code has exactly the same complexity as debugging multi-threading code - if not less...
Because thread machinery is much more complex than event one - just compare amount of code in scheduler and the whole kevent - kernel/sched.c has about the same size as the whole kevent :)
Quoted 5 lines
the kernel /IS/ multi-threaded code.
which statement of yours is also patently, absurdly untrue. Multithreaded code is harder to debug than process based code, but it is still a breeze compared to complex state-machines...
It seems that we are talking about different levels.
Model I propose to use in userspace - very simple events mostly about completion of the request - they are simple to use and simple to debug. It can be slightly more hard to debug, than the simplest threading model (one thread - one logical entity, which whould never work with others) though.
Quoted 1 line
From userspace point of view it is about the same complexity to check
why event is not marked as ready, or why some thread never got scheduled...
And we do not get into account possible synchronization methods needed to run multithreaded code without problems.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Hi!
Quoted 11 lines
Quoted 10 lines
I think what you are not hearing, and what everyone else is saying (INCLUDING Linus), is that for most programmers, state machines are much, much harder to program, understand, and debug compared to multi-threaded code. You may disagree (were you a MacOS 9 programmer in another life?), and it may not even be true for you if you happen to be one of those folks more at home with Scheme continuations, for example. But it is true that for most kernel programmers, threaded programming is much easier to understand, and we need to engineer the kernel for what will be maintainable for the majority of the kernel development community.
Quoted 3 lines
I understand that - and I totally agree.
But when more complex, more bug-prone code results in higher performance
- that must be used. We have linked lists and binary trees - the latter
No-o. Kernel is not designed like that.
Often, more complex and slightly faster code exists, and we simply use slower variant, because it is fast enough.
10% gain in speed is NOT worth major complexity increase.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 17 lines · Pavel Machek
Hi!
Quoted 11 lines
Quoted 10 lines
I think what you are not hearing, and what everyone else is saying (INCLUDING Linus), is that for most programmers, state machines are much, much harder to program, understand, and debug compared to multi-threaded code. You may disagree (were you a MacOS 9 programmer in another life?), and it may not even be true for you if you happen to be one of those folks more at home with Scheme continuations, for example. But it is true that for most kernel programmers, threaded programming is much easier to understand, and we need to engineer the kernel for what will be maintainable for the majority of the kernel development community.
Quoted 3 lines
I understand that - and I totally agree.
But when more complex, more bug-prone code results in higher performance
- that must be used. We have linked lists and binary trees - the latter
Quoted 6 lines
No-o. Kernel is not designed like that.
Often, more complex and slightly faster code exists, and we simply use slower variant, because it is fast enough.
10% gain in speed is NOT worth major complexity increase.
Should I create a patch to remove rb-tree implementation? That practice is stupid IMO.
Quoted 4 lines
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Signature · 1 line
Evgeniy Polyakov
Hi!
Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
I understand that - and I totally agree.
But when more complex, more bug-prone code results in higher performance
- that must be used. We have linked lists and binary trees - the latter
Quoted 8 lines
Quoted 6 lines
No-o. Kernel is not designed like that.
Often, more complex and slightly faster code exists, and we simply use slower variant, because it is fast enough.
10% gain in speed is NOT worth major complexity increase.
Should I create a patch to remove rb-tree implementation?
If you can replace them with something simpler, and no worse than 10% slower in worst case, then go ahead. (We actually tried to do that at some point, only to realize that efence stresses vm subsystem in very unexpected/unfriendly way).
Quoted 1 line
That practice is stupid IMO.
Too bad. Now you can start Linux fork called Eugenix.
(But really, Linux is not "maximum performance at any cost". Linux is "how fast can we get that while keeping it maintainable?").
That is why, while arguing syslets vs. kevents, you need need to argue not "kevents are faster because they avoid context switch overhead", but "kevents are _so much_ faster that it is worth the added complexity". And Ingo seems to showing you they are not _so much_ faster.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 8 lines · Pavel Machek
Quoted 3 lines
Quoted 1 line
10% gain in speed is NOT worth major complexity increase.
Should I create a patch to remove rb-tree implementation?
If you can replace them with something simpler, and no worse than 10% slower in worst case, then go ahead. (We actually tried to do that at some point, only to realize that efence stresses vm subsystem in very unexpected/unfriendly way).
Agh, only 10% in the worst case.
I think you can not even imagine what tricks network uses to get at least aditional 1% out of the box.
Using such logic you can just abandon any further development, since it work as is right now.
Quoted 6 lines
Quoted 1 line
That practice is stupid IMO.
Too bad. Now you can start Linux fork called Eugenix.
(But really, Linux is not "maximum performance at any cost". Linux is "how fast can we get that while keeping it maintainable?").
Should I read it like: we do not understand what it is and thus we do not want it?
Quoted 5 lines
That is why, while arguing syslets vs. kevents, you need need to argue not "kevents are faster because they avoid context switch overhead", but "kevents are
_somuch_faster that it is worth the added complexity". And Ingo seems to showing you they are not_somuch_faster.
Threadlets behave much worse without event driven model, events can behave worse without backed threads, they are mutually compensating.
I posted kevent/epoll benchmarks and related design issues too many times both with handmade applications (which might be broken as hell) and popular open-source servers to repeat them again.
Quoted 4 lines
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
I posted kevent/epoll benchmarks and related design issues too many times both with handmade applications (which might be broken as hell) and popular open-source servers to repeat them again.
numbers are crutial here - and given the epoll bugs in the evserver code that we found, do you have updated evserver benchmark results that compare epoll to kevent? I'm wondering why epoll has half the speed of kevent in those measurements - i suspect some possible benchmarking bug. The queueing model of epoll and kevent is roughly comparable, both do only a constant number of steps to serve one particular request, regardless of how many pending connections/requests there are. What is the CPU utilization of the server system during an epoll test, and what is the CPU utilization during a kevent test? 100% utilized in both cases?
Ingo
Quoted 7 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
I posted kevent/epoll benchmarks and related design issues too many times both with handmade applications (which might be broken as hell) and popular open-source servers to repeat them again.
Quoted 10 lines
numbers are crutial here - and given the epoll bugs in the evserver code that we found, do you have updated evserver benchmark results that compare epoll to kevent? I'm wondering why epoll has half the speed of kevent in those measurements - i suspect some possible benchmarking bug. The queueing model of epoll and kevent is roughly comparable, both do only a constant number of steps to serve one particular request, regardless of how many pending connections/requests there are. What is the CPU utilization of the server system during an epoll test, and what is the CPU utilization during a kevent test? 100% utilized in both cases?
Yes, it is about 98-100% in both cases.
I've just re-run tests on my amd64 test machine without debug options:
epoll 4794.23
kevent 6468.95
here are full client 'ab' outputs for epoll and kevent servers (epoll does not contain EPOLLET as you requested, but it does not look like it change performance in my case).
epoll ab aoutput:
# ab -c8000 -n80000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.0.48 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.27 Server Hostname: 192.168.0.48 Server Port: 80
Document Path: / Document Length: 3521 bytes
Concurrency Level: 8000 Time taken for tests: 16.686737 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 309760000 bytes HTML transferred: 281680000 bytes Requests per second: 4794.23 [#/sec] (mean) Time per request: 1668.674 [ms] (mean) Time per request: 0.209 [ms] (mean, across all concurrent
requests)
Transfer rate: 18128.17 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 159 779 110.1 799 921 Processing: 468 866 77.4 869 988 Waiting: 63 426 212.3 425 921
Total: 1145 1646 115.6 1660 1873
Percentage of the requests served within a certain time (ms)
50% 1660 66% 1661 75% 1662 80% 1663 90% 1806 95% 1830 98% 1833 99% 1834
100% 1873 (longest request)
kevent ab output:
# ab -c8000 -n80000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.0.48 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.27 Server Hostname: 192.168.0.48 Server Port: 80
Document Path: / Document Length: 3521 bytes
Concurrency Level: 8000 Time taken for tests: 12.366775 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 317047104 bytes HTML transferred: 288306522 bytes Requests per second: 6468.95 [#/sec] (mean) Time per request: 1236.677 [ms] (mean) Time per request: 0.155 [ms] (mean, across all concurrent
requests)
Transfer rate: 25036.12 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 130 364 871.1 275 9347 Processing: 178 298 42.5 296 580 Waiting: 31 202 65.8 210 369 Total: 411 663 887.0 572 9722
Percentage of the requests served within a certain time (ms)
50% 572 66% 573 75% 618 80% 640 90% 684 95% 709 98% 721
99% 3455
100% 9722 (longest request)
Notice how percentage of the requests served within a certain time differs for kevent and epoll. And this server does not include ready-on-submission kevent optimization.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 4 lines · Evgeniy Polyakov
I've just re-run tests on my amd64 test machine without debug options:
epoll 4794.23
kevent 6468.95
could you please post the two URLs for the exact evserver code used for these measurements? (even if you did so already in the past - best to have them always together with the numbers) Thanks!
Ingo
Quoted 11 lines · Ingo Molnar
Quoted 4 lines · Evgeniy Polyakov
I've just re-run tests on my amd64 test machine without debug options:
epoll 4794.23
kevent 6468.95could you please post the two URLs for the exact evserver code used for these measurements? (even if you did so already in the past - best to have them always together with the numbers) Thanks!
I've uploaded them to:
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_epoll.c
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_kevent.c
I also changed client socket to nonblocking mode with the same result in epoll server. If you will find it broken, please send me corrected to test too.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 4 lines · Evgeniy Polyakov
I've uploaded them to:
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_epoll.c
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_kevent.c
thanks.
Quoted 2 lines
I also changed client socket to nonblocking mode with the same result in epoll server. [...]
what does this mean exactly? Did you change this line in evserver_epoll.c:
//fcntl(cs, F_SETFL, O_NONBLOCK);
to:
fcntl(cs, F_SETFL, O_NONBLOCK);
and the result was the same?
Ingo
Quoted 16 lines · Ingo Molnar
Quoted 4 lines · Evgeniy Polyakov
I've uploaded them to:
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_epoll.c
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_kevent.cthanks.
Quoted 2 lines
I also changed client socket to nonblocking mode with the same result in epoll server. [...]
what does this mean exactly? Did you change this line in
evserver_epoll.c:
Quoted 7 lines
//fcntl(cs, F_SETFL, O_NONBLOCK);to:
fcntl(cs, F_SETFL, O_NONBLOCK);and the result was the same?
Yep.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
I also changed client socket to nonblocking mode with the same result in epoll server. If you will find it broken, please send me corrected to test too.
this line in evserver_kevent.c looks a bit fishy:
err = recv(s, buf, 100, 0);
because on the evserver_epoll.c side the following is done:
err = recv(s, buf, 4096, 0);
now, for 'ab', the request size is 76 bytes, so it should fit fine functionality-wise. But, the TCP stack might decide differently of whether to return with a partial packet depending on how much data is requested. I dont know whether it actually makes a difference in the TCP flow decisions, and whether it makes a performance difference in your test, but safest would be to use 4096 in both cases.
in general, please make sure the exact same system calls are done in the client function. (except of course for the event queueing syscalls themselves)
Ingo
Quoted 5 lines · Ingo Molnar
Quoted 3 lines
I also changed client socket to nonblocking mode with the same result in epoll server. If you will find it broken, please send me corrected to test too.
this line in
evserver_kevent.clooks a bit fishy:
this one in evserver_kevent.c looks problematic too:
shutdown(s, SHUT_RDWR);
close(s);as evserver_epoll.c only does:
close(s);
again, there might be TCP control flow differences due to this. [ Or the removal of this shutdown() call might be a small speedup for the kevent case ;) ]
Also, the order of fd and socket close() is different in the two cases. It shouldnt make any difference - but that too just makes the results harder to trust. Would it be so hard to introduce a single handle_web_request() function that is exactly the same in the two tests? All the queueing details (which are of course different in the epoll and the kevent case) should be in the client function, which calls handle_web_request().
Ingo
Quoted 14 lines · Ingo Molnar
Quoted 5 lines · Ingo Molnar
Quoted 3 lines
I also changed client socket to nonblocking mode with the same result in epoll server. If you will find it broken, please send me corrected to test too.
this line in
evserver_kevent.clooks a bit fishy:this one in
evserver_kevent.clooks problematic too:shutdown(s, SHUT_RDWR); close(s);
Quoted 7 lines
as
evserver_epoll.conly does:close(s);again, there might be TCP control flow differences due to this. [ Or the removal of this
shutdown()call might be a small speedup for the kevent case ;) ]
:)
Quoted 7 lines
Also, the order of fd and socket
close()is different in the two cases. It shouldnt make any difference - but that too just makes the results harder to trust. Would it be so hard to introduce a singlehandle_web_request()function that is exactly the same in the two tests? All the queueing details (which are of course different in the epoll and the kevent case) should be in the client function, which callshandle_web_request().
I've removed shutdown - things are the same.
Sometimes kevent performance drops to lower numbers and its graph of times needed to handle events has high platoes (with and without shutdown - it was always), like this:
Percentage of the requests served within a certain time (ms)
50% 128 66% 486 75% 505 80% 507 90% 732 95% 3087 // something is wrong at this point 98% 9058 99% 9072 100% 15562 (longest request)
it is possible that threre are some other bugs in the server though, which prevent sockets from being quicly closed and thus its processing time increases - I do not know for sure the root of that event.
I separated epoll and kevent servers, since originally kevent server included additional kevent features, but then new ones were added and I moved slowly to the similar to epoll case.
Current version of the server was a pre-test one for lighttpd patches, so essentially it should be like epoll except minor details.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
I separated epoll and kevent servers, since originally kevent server included additional kevent features, but then new ones were added and I moved slowly to the similar to epoll case.
i dont care whether they are separate or not - but you have not replied to the request that there be a handle_web_request() function in /both/ files, which is precisely the same function. I didnt ask you to merge the two files - i only asked for the two web handling functions to be one and the same function.
Ingo
Quoted 7 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
I separated epoll and kevent servers, since originally kevent server included additional kevent features, but then new ones were added and I moved slowly to the similar to epoll case.
Quoted 5 lines
i dont care whether they are separate or not - but you have not replied to the request that there be a
handle_web_request()function in /both/ files, which is precisely the same function. I didnt ask you to merge the two files - i only asked for the two web handling functions to be one and the same function.
They are not the same in general - if kevent is ready immediately, there will not be its removing from kevent tree, but current kevent server has it always not-immediately for lighttpd tests - so functions are the same:open()sendfile()cork_off
close(fd)
close(s)remove_event_from_the_kernel
with the same parameters.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 16 lines · Evgeniy Polyakov
Quoted 5 lines
i dont care whether they are separate or not - but you have not replied to the request that there be a
handle_web_request()function in /both/ files, which is precisely the same function. I didnt ask you to merge the two files - i only asked for the two web handling functions to be one and the same function.They are not the same in general - if kevent is ready immediately, there will not be its removing from kevent tree, but current kevent server has it always not-immediately for lighttpd tests - so functions are the same:
open()sendfile()cork_off
close(fd)
close(s)remove_event_from_the_kernel
Quoted 1 line
with the same parameters.
you /STILL/ dont understand. I'm only talking about evserver_epoll.c and evserver_kevent.c. Not about lighttpd. Not about historic reasons. I simply suggested a common-sense change:
| | Would it be so hard to introduce a single handle_web_request() | | function that is exactly the same in the two tests? All the queueing | | details (which are of course different in the epoll and the kevent | | case) should be in the client function, which calls | | handle_web_request().
i.e. put remove_event_from_the_kernel() (kweb_kevent_remove()) and evtest_remove()) into a SEPARATE client function, which calls the /common/ handle_web_request(sock) function. You can do the immediate-removal in that separate, kevent-specific client function - but the socket function, handle_web_request(sock) should be /perfectly identical/ in the two files.
I.e.:
static inline int handle_web_request(int s)
{
int err, fd, on = 0;
off_t offset = 0;
int count = 40960;
char path[] = "/tmp/index.html";
char buf[4096];
err = recv(s, buf, sizeof(buf), 0);
if (err <= 0)
return err;
fd = open(path, O_RDONLY);
if (fd == -1)
return fd;
err = sendfile(s, fd, &offset, count);
if (err < 0) {
ulog_err("Failed send %d bytes: fd=%d.\n", count, s);
close(fd);
return err;
}
setsockopt(s, SOL_TCP, TCP_CORK, &on, sizeof(on));
close(fd);
close(s); /* No keepalive */
return 0;
}And in evserver_epoll.c do this:
static int evtest_callback_client(int s)
{
int err = handle_web_request(s);
if (err)
evtest_remove(s);
return err;
}and in evserver_kevent.c do this:
static int kweb_callback_client(struct ukevent *e, int im)
{
int err = handle_web_request(e->id.raw[0]);
if (err || !im)
kweb_kevent_remove(e);
return err;
}ok?
Btw., am i correct that in this particular 'ab' test, the 'immediately' flag is always zero, i.e. kweb_kevent_remove() is always called?
Ingo
Quoted 1 line · Ingo Molnar
ok?
I undesrtood you couple of mails ago.
No problem, I can put processing into the same function called from different servers :)
Quoted 2 lines
Btw., am i correct that in this particular 'ab' test, the 'immediately' flag is always zero, i.e.
kweb_kevent_remove()is always called?
Yes.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 13 lines · Evgeniy Polyakov
Quoted 1 line · Ingo Molnar
ok?
I undesrtood you couple of mails ago.
No problem, I can put processing into the same function called from different servers :)Quoted 2 lines
Btw., am i correct that in this particular 'ab' test, the 'immediately' flag is always zero, i.e.
kweb_kevent_remove()is always called?Yes.
Quoted 1 line
Ingo
I can tell you that the problem (at least on my machine) comes from :
gettimeofday(&tm, NULL);
in evserver_epoll.c
Quoted 5 lines · Eric Dumazet
I can tell you that the problem (at least on my machine) comes from :
gettimeofday(&tm, NULL);in
evserver_epoll.c
yeah, that's another difference - especially if it's something like an Athlon64 and gettimeofday falls back to pm-timer, that could explain the performance difference. That's why i repeatedly asked Evgeniy to use the /very same/ client function for both the epoll and the kevent test and redo the measurements. The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Ingo
Quoted 7 lines · Ingo Molnar
Quoted 5 lines · Eric Dumazet
I can tell you that the problem (at least on my machine) comes from :
gettimeofday(&tm, NULL);in
evserver_epoll.c
Quoted 7 lines
yeah, that's another difference - especially if it's something like an Athlon64 and gettimeofday falls back to pm-timer, that could explain the performance difference. That's why i repeatedly asked Evgeniy to use the /very same/ client function for both the epoll and the kevent test and redo the measurements. The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Also, ab is quite lame... Maybe we could use a epoll based 'stresser'
On my machines (again ...), ab is the slow thing... not the 'server'
Some small differences in behavior could have a big impact on ab (and you could think there is a problem on the remote side)
Quoted 1 line · Eric Dumazet
On my machines (again ...), ab is the slow thing... not the 'server'
Evgeniy said that both in the epoll and the kevent case the server side CPU was 98%-100% busy - so inefficiencies on the client side do not matter that much - the server is saturated. It's that "kevent is 25% faster than epoll" claim that i'm probing mainly.
Ingo
Quoted 9 lines · Ingo Molnar
Quoted 5 lines · Eric Dumazet
I can tell you that the problem (at least on my machine) comes from :
gettimeofday(&tm, NULL);in
evserver_epoll.c
Quoted 7 lines
yeah, that's another difference - especially if it's something like an Athlon64 and gettimeofday falls back to pm-timer, that could explain the performance difference. That's why i repeatedly asked Evgeniy to use the /very same/ client function for both the epoll and the kevent test and redo the measurements. The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
There is no gettimeofday() in the running code anymore, and it was placed not in common server processing code btw.
Ingo, do you really think I will send mails with faked benchmarks? :))
Btw, there were never almost twice perfromance increase - epoll in my tests always showed 4-5 thousands requests per second, kevent - up to 7 thausands.
That starts looking like ghost hunting, Ingo, you already said that you do not see any need in kevent, have you changed your opinion on that?
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 14 lines · Evgeniy Polyakov
Quoted 6 lines
Quoted 5 lines
I can tell you that the problem (at least on my machine) comes from :
gettimeofday(&tm, NULL);in
evserver_epoll.cQuoted 7 lines
yeah, that's another difference - especially if it's something like an Athlon64 and gettimeofday falls back to pm-timer, that could explain the performance difference. That's why i repeatedly asked Evgeniy to use the /very same/ client function for both the epoll and the kevent test and redo the measurements. The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Quoted 4 lines
There is no
gettimeofday()in the running code anymore, and it was placed not in common server processing code btw.Ingo, do you really think I will send mails with faked benchmarks? :))
no, i'd not be in this discussion anymore if i thought that. But i do think that your benchmark results are extremely sloppy, that make your conclusions on them essentially useless.
you were hurling quite colorful and strong assertions into this discussion, backed up by these numbers, so you should expect at least some minimal amount of scrutiny of those numbers.
Quoted 7 lines
Quoted 3 lines
[...] The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Btw, there were never almost twice perfromance increase - epoll in my tests always showed 4-5 thousands requests per second, kevent - up to 7 thausands.
i'm referring to your claim in this mail of yours from 4 days ago for example:
http://lkml.org/lkml/2007/2/25/116
"But note, that on my athlon64 3500 test machine kevent is about 7900
requests per second compared to 4000+ epoll, so expect a challenge."
no matter how i look at it, but 7900 is 1.9 times 4000 - which is "almost twice".
Ingo
Quoted 22 lines · Ingo Molnar
Quoted 14 lines · Evgeniy Polyakov
Quoted 6 lines
Quoted 5 lines
I can tell you that the problem (at least on my machine) comes from :
gettimeofday(&tm, NULL);in
evserver_epoll.cQuoted 7 lines
yeah, that's another difference - especially if it's something like an Athlon64 and gettimeofday falls back to pm-timer, that could explain the performance difference. That's why i repeatedly asked Evgeniy to use the /very same/ client function for both the epoll and the kevent test and redo the measurements. The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Quoted 4 lines
There is no
gettimeofday()in the running code anymore, and it was placed not in common server processing code btw.Ingo, do you really think I will send mails with faked benchmarks? :))
Quoted 7 lines
no, i'd not be in this discussion anymore if i thought that. But i do think that your benchmark results are extremely sloppy, that make your conclusions on them essentially useless.
you were hurling quite colorful and strong assertions into this discussion, backed up by these numbers, so you should expect at least some minimal amount of scrutiny of those numbers.
This discussion was about event driven vs. thread driven IO models, and threadlet only behaves like event driven because in my tests there was exactly one threadlet rescheduling per severa thousands of clients.
Kevent is just a logical interpolation of performance of event driven model.
My assumptions were based not on kevent performance, but on the fact, that event delivery is much faster and simpler than thread handling.
Ugh, I'm starting that stupid talk again - let's just jump to the end - I agree that in real-life high-performance systems both models must be used.
Peace? :)
Quoted 11 lines
Quoted 7 lines
Quoted 3 lines
[...] The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Btw, there were never almost twice perfromance increase - epoll in my tests always showed 4-5 thousands requests per second, kevent - up to 7 thausands.
i'm referring to your claim in this mail of yours from 4 days ago for example:
Quoted 7 lines
http://lkml.org/lkml/2007/2/25/116
"But note, that on my athlon64 3500 test machine kevent is about 7900
requests per second compared to 4000+ epoll, so expect a challenge."no matter how i look at it, but 7900 is 1.9 times 4000 - which is "almost twice".
After your changes epoll increased to 5k.
I can easily reproduce 6300/4300 split, but can not get more than 7k for kevent (with oprofile/idle=poll at least).
I've completed 800k run:
kevent 4800
epoll 4450
with tons ofoverflows in 'ab':
Write errors: 0 Total transferred: -1197367296 bytes HTML transferred: -1478167296 bytes Requests per second: 4440.67 [#/sec] (mean) Time per request: 1801.529 [ms] (mean) Time per request: 0.225 [ms] (mean, across all concurrent
requests)
Transfer rate: -6490.62 [Kbytes/sec] received
Any other bench?
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 13 lines · Evgeniy Polyakov
Quoted 13 lines
Quoted 7 lines
Quoted 3 lines
[...] The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Btw, there were never almost twice perfromance increase - epoll in my tests always showed 4-5 thousands requests per second, kevent - up to 7 thausands.
i'm referring to your claim in this mail of yours from 4 days ago for example:
Quoted 7 lines
Quoted 5 lines
"But note, that on my athlon64 3500 test machine kevent is about 7900
requests per second compared to 4000+ epoll, so expect a challenge."no matter how i look at it, but 7900 is 1.9 times 4000 - which is "almost twice".
After your changes epoll increased to 5k.
Can we please stop this pointless episode of benchmarketing, where every mail of yours shows different results and you even deny having said something which you clearly said just a few days ago? At this point i simply cannot trust the numbers you are posting, nor is the discussion style you are following productive in any way in my opinion.
(you are never ever wrong, and if you are proven wrong on topic A you claim it is an irrelevant topic (without even admitting you were wrong about it) and you point to topic B claiming it's the /real/ topic you talked about all along. And along the way you are slandering other projects like epoll and threadlets, distorting the discussion. This kind of keep-the-ball-moving discussion style is effective in politics but IMO it's a waste of time when developing a kernel.)
Ingo
Quoted 22 lines · Ingo Molnar
Quoted 19 lines · Evgeniy Polyakov
Quoted 18 lines
Quoted 7 lines
Quoted 3 lines
[...] The numbers are still highly suspect - and we are already down from the prior claim of kevent being almost twice as fast to a 25% difference.
Btw, there were never almost twice perfromance increase - epoll in my tests always showed 4-5 thousands requests per second, kevent - up to 7 thausands.
i'm referring to your claim in this mail of yours from 4 days ago for example:
http://lkml.org/lkml/2007/2/25/116
"But note, that on my athlon64 3500 test machine kevent is about 7900
requests per second compared to 4000+ epoll, so expect a challenge."no matter how i look at it, but 7900 is 1.9 times 4000 - which is "almost twice".
Quoted 7 lines
Quoted 1 line
After your changes epoll increased to 5k.
Can we please stop this pointless episode of benchmarketing, where every mail of yours shows different results and you even deny having said something which you clearly said just a few days ago? At this point i simply cannot trust the numbers you are posting, nor is the discussion style you are following productive in any way in my opinion.
I just show what I see in tests - I do not perform deep analysis of that, since I do not see why it should be done - it is not fake, it is not fantasy - real behaviour which is observed in my test machine, if it will sudenly change I will report it.
Btw, I showed cases when epoll behaved better than kevent and performance was unbeatable 9k requests per second - I do not know, why it happend - maybe some cache related issues, other process all slept in once, increased radiation or strong wind blew away my bad aura - it is not reproducible on demand too.
Quoted 7 lines
(you are never ever wrong, and if you are proven wrong on topic A you claim it is an irrelevant topic (without even admitting you were wrong about it) and you point to topic B claiming it's the /real/ topic you talked about all along. And along the way you are slandering other projects like epoll and threadlets, distorting the discussion. This kind of keep-the-ball-moving discussion style is effective in politics but IMO it's a waste of time when developing a kernel.)
Heh - that is why I'm not subscribed to lkml@ - it tooo frequently ends up with politics :)
What we are talking about - we try to insult each other with something, that was supposed to be said after some assumption on theoretical mental exercise? I can only laugh on that :)
Ingo, I never ever tried to show that something is broken - that is fantasy based on straight words, not on the real intension.
I never said epoll is broken. Absolutely.
I never said threadlet is broken. Absolutely.
I just showed that it is not (in my opinion) right decision to use threadlets for IO based model instead of event driven - it is not based on kevent performance (I _never_ stated it as a main factor - kevent was only an example of event driven model, you were confused it with kevent AIO, which is different beast), but instead on experience with nptl threads and linuxthreads, and related rescheduling overhead compared to userspace one.
I showed kevent as a possible usage scenario - since it does support own AIO. And you started to fight against it in every detail, since you think kevent is not a good idea to handle AIO model - well, it can be pefectly correct, I showed kevent AIO (please do not think that kevent and kevent AIO are the same - the latter is just one of the possible users I implemented, it only uses kevent to deliver completion event to userspace) as possible AIO implementation, but not _kevent_ itself.
But somehow we ended with binding to me some words I never said and ideas I never based my assumptions on... I do not really think you even remotely wanted to make any somehow personal assumptions on what we had discussed.
We even concluded, that perfect IO model should use both approaches to really scale - both threadlets with its on-demand-only rescheduling, and event driven ring.
You pointed your opinion on kevents - well, I can not agree with it, but that is your right not to like something.
Let's not continue bad practice of kicking each other just because there were some problematic roots which noone even remember correctly - let's do not make a mistake of pointing something personal out of trivial bits
- if you will be in Russia of around any time soon I will happily buy you a beer or what you prefer :)
So, let's just draw a line:
kevent was showed to people, and its performance, although flacky, is a bit faster than epoll. Threadlets bound to any event driven ring do not show any performance degradation in network driven setup with small number of reschedulings with all advantages of simpler programming. So, repeating myself, both models (not kevent and threadlet, but event driven and thread based) should be used to achieve the maximum performance.
So, I will draw yet another request for peace and fun and interesting technical discussion. Peace?
Anyway, that was interesting discussion, thanks a lot for all participants :)
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 7 lines · Ingo Molnar
Quoted 1 line
After your changes epoll increased to 5k.
Can we please stop this pointless episode of benchmarketing, where every mail of yours shows different results and you even deny having said something which you clearly said just a few days ago? At this point i simply cannot trust the numbers you are posting, nor is the discussion style you are following productive in any way in my opinion.
Agreed. Can we focus on the topic here? We're still missing proper FPU context switch in the move_user_context(). In v6?
- Davide
Quoted 2 lines · Davide Libenzi
[...] We're still missing proper FPU context switch in the
move_user_context(). [...]
yeah - i'm starting to be of the opinion that the FPU context should stay with the threadlet, exclusively. I.e. when calling a threadlet, the 'outer loop' (the event loop) should not leak FPU context into the threadlet and then expect it to be replicated from whatever random point the threadlet ended up sleeping at. It would be possible, but it just makes no sense. What makes most sense is to just keep the FPU context with the threadlet, and to let the 'new head' use an initial (unused) FPU context. And it's in fact the threadlet that will most likely have an acrive FPU context across a system call, not the outer loop. In other
words: no special FPU support needed at all for threadlets (i.e. no flipping needed even) - this behavior just naturally happens in the current implementation. Hm?
Ingo
Quoted 6 lines · Ingo Molnar
Quoted 2 lines · Davide Libenzi
[...] We're still missing proper FPU context switch in the
move_user_context(). [...]
Quoted 12 lines
yeah - i'm starting to be of the opinion that the FPU context should stay with the threadlet, exclusively. I.e. when calling a threadlet, the 'outer loop' (the event loop) should not leak FPU context into the threadlet and then expect it to be replicated from whatever random point the threadlet ended up sleeping at. It would be possible, but it just makes no sense. What makes most sense is to just keep the FPU context with the threadlet, and to let the 'new head' use an initial (unused) FPU context. And it's in fact the threadlet that will most likely have an acrive FPU context across a system call, not the outer loop. In other
words: no special FPU support needed at all for threadlets (i.e. no flipping needed even) - this behavior just naturally happens in the current implementation. Hm?
I think that the "dirty" FPU context must, at least, follow the new head. That's what the userspace sees, and you don't want an async_exec to re-emerge with a different FPU context.
I think it should also follow the async thread (old, going-to-sleep, thread), since a threadlet might have that dirtied, and as a consequence it'll want to find it back when it's re-scheduled.
So, IMO, if the USEDFPU bit is set, we need to sync the dirty FPU context with an early unlazy_fpu(), *and* copy the sync'd FPU context to the new head. This should really be a fork of the dirty FPU context IMO, and should only happen if the USEDFPU bit is set.
- Davide
Quoted 3 lines · Davide Libenzi
I think that the "dirty" FPU context must, at least, follow the new head. That's what the userspace sees, and you don't want an
async_execto re-emerge with a different FPU context.
well. I think there's some confusion about terminology, so please let me describe everything in detail. This is how execution goes:
outer loop() {
call_threadlet();
}this all runs in the 'head' context. call_threadlet() always switches to the 'threadlet stack'. The 'outer context' runs in the 'head stack'. If, while executing the threadlet function, we block, then the threadlet-thread gets to keep the task (the threadlet stack and also the FPU), and blocks - and we pick a 'new head' from the thread pool and continue executing in that context - right after the call_threadlet() function, in the 'old' head's stack. I.e. it's as if we returned immediately from call_threadlet(), with a return code that signals that the 'threadlet went async'.
now, the FPU state that was when the threadlet blocked is totally meaningless to the 'new head' - that FPU state is from the middle of the threadlet execution.
and here is where thinking about threadlets as a function call and not as an asynchronous context helps alot: the classic gcc convention for FPU use & function calls should apply: gcc does not call an external function with an in-use FPU stack/register, it always neatly unuses it, as no FPU register is callee-saved, all are caller-saved.
Quoted 4 lines
So, IMO, if the USEDFPU bit is set, we need to sync the dirty FPU context with an early
unlazy_fpu(), *and* copy the sync'd FPU context to the new head. This should really be a fork of the dirty FPU context IMO, and should only happen if the USEDFPU bit is set.
why? The only effect this will have is a slowdown :) The FPU context from the middle of the threadlet function is totally meaningless to the 'new head'. It might be anything. (although in practice system calls are almost never called with a truly in-use FPU.)
Ingo
Quoted 24 lines · Ingo Molnar
Quoted 3 lines · Davide Libenzi
I think that the "dirty" FPU context must, at least, follow the new head. That's what the userspace sees, and you don't want an
async_execto re-emerge with a different FPU context.well. I think there's some confusion about terminology, so please let me describe everything in detail. This is how execution goes:
outer loop() { call_threadlet(); }this all runs in the 'head' context.
call_threadlet()always switches to the 'threadlet stack'. The 'outer context' runs in the 'head stack'. If, while executing the threadlet function, we block, then the threadlet-thread gets to keep the task (the threadlet stack and also the FPU), and blocks - and we pick a 'new head' from the thread pool and continue executing in that context - right after thecall_threadlet()function, in the 'old' head's stack. I.e. it's as if we returned immediately fromcall_threadlet(), with a return code that signals that the 'threadlet went async'.
Quoted 3 lines
now, the FPU state that was when the threadlet blocked is totally meaningless to the 'new head' - that FPU state is from the middle of the threadlet execution.
For threadlets, it might be. Now think about a task wanting to dispatch N parallel AIO requests as N independent syslets.
Think about this task having USEDFPU set, so the FPU context is dirty. When it returns from async_exec, with one of the requests being become sleepy, it needs to have the same FPU context it had when it entered, otherwise it won't prolly be happy.
For the same reason a schedule() must preserve/sync the "prev" FPU context, to be reloaded at the next FPU fault.
Quoted 9 lines
Quoted 4 lines
So, IMO, if the USEDFPU bit is set, we need to sync the dirty FPU context with an early
unlazy_fpu(), *and* copy the sync'd FPU context to the new head. This should really be a fork of the dirty FPU context IMO, and should only happen if the USEDFPU bit is set.why? The only effect this will have is a slowdown :) The FPU context from the middle of the threadlet function is totally meaningless to the 'new head'. It might be anything. (although in practice system calls are almost never called with a truly in-use FPU.)
See above ;)
- Davide
Quoted 8 lines · Davide Libenzi
For threadlets, it might be. Now think about a task wanting to dispatch N parallel AIO requests as N independent syslets.
Think about this task having USEDFPU set, so the FPU context is dirty. When it returns fromasync_exec, with one of the requests being become sleepy, it needs to have the same FPU context it had when it entered, otherwise it won't prolly be happy.
For the same reason aschedule()must preserve/sync the "prev" FPU context, to be reloaded at the next FPU fault.
And if you actually think this through, I think you will arrive at (a subset of) the conclusions I did a week ago: to keep the threadlets lightweight enough to schedule and migrate cheaply, they can't be allowed to "own" their own FPU and TLS context. They have to be allowed to _use_ the FPU (or they're useless) and to _use_ TLS (or they can't use any glibc wrapper around a syscall, since they practically all set the thread-local errno). But they have to "quiesce" the FPU and stash any thread-local state they want to keep on their stack before entering the next syscall, or else it'll get clobbered.
Keep thinking, especially about FPU flags, and you'll see why threadlets spawned from the _same_ threadlet entrypoint should all run in the same pool of threads, one per CPU, while threadlets from _different_ entrypoints should never run in the same thread (FPU/TLS context). You'll see why threadlets in the same pool shouldn't be permitted to preempt one another except at syscalls that block, and the cost of preempting the real thread associated with one threadlet pool with another real thread associated with a different threadlet pool is the same as any other thread switch. At which point, threadlet pools are themselves first-class objects (to use the snake oil phrase), and might as well be enhanced to a data structure that has efficient operations for reprioritization, bulk cancellation, and all that jazz.
Did I mention that there is actually quite a bit of prior art in this area, which makes a much better guide to the design of round wheels than micro-benchmarks do?
Cheers,
- Michael
Quoted 30 lines · Davide Libenzi
Quoted 24 lines · Ingo Molnar
Quoted 3 lines · Davide Libenzi
I think that the "dirty" FPU context must, at least, follow the new head. That's what the userspace sees, and you don't want an
async_execto re-emerge with a different FPU context.well. I think there's some confusion about terminology, so please let me describe everything in detail. This is how execution goes:
outer loop() { call_threadlet(); }this all runs in the 'head' context.
call_threadlet()always switches to the 'threadlet stack'. The 'outer context' runs in the 'head stack'. If, while executing the threadlet function, we block, then the threadlet-thread gets to keep the task (the threadlet stack and also the FPU), and blocks - and we pick a 'new head' from the thread pool and continue executing in that context - right after thecall_threadlet()function, in the 'old' head's stack. I.e. it's as if we returned immediately fromcall_threadlet(), with a return code that signals that the 'threadlet went async'.Quoted 3 lines
now, the FPU state that was when the threadlet blocked is totally meaningless to the 'new head' - that FPU state is from the middle of the threadlet execution.
Quoted 8 lines
For threadlets, it might be. Now think about a task wanting to dispatch N parallel AIO requests as N independent syslets.
Think about this task having USEDFPU set, so the FPU context is dirty. When it returns fromasync_exec, with one of the requests being become sleepy, it needs to have the same FPU context it had when it entered, otherwise it won't prolly be happy.
For the same reason aschedule()must preserve/sync the "prev" FPU context, to be reloaded at the next FPU fault.
The point Ingo was making is that the x86 ABI already requires the FPU context to be saved before *all* function calls.
Unfortunately, this isn't true of other ABIs -- looking over the psABIs specs I have laying around, AMD64, PPC64, and MIPS require at least part of the FPU state to be preserved across function calls, and I'm sure this is also true of others.
Then there's the other nasty details of new thread creation -- thankfully, the contents of the TLS isn't inherited from the parent thread, but it still needs to be initialized; not to mention all the other details involved in pthread creation and destruction.
I don't see any way around the pthread issues other than making a libc upcall on return from the first system call that blocked.
Signature · 1 line
Nicholas Miell <[email protected]>
Quoted 2 lines · Nicholas Miell
The point Ingo was making is that the x86 ABI already requires the FPU context to be saved before *all* function calls.
I've not seen that among Ingo's points, but yeah some status is caller saved. But, aren't things like status word and control bits callee saved? If that's the case, it might require proper handling.
- Davide
Quoted 9 lines · Davide Libenzi
Quoted 2 lines · Nicholas Miell
The point Ingo was making is that the x86 ABI already requires the FPU context to be saved before *all* function calls.
I've not seen that among Ingo's points, but yeah some status is caller saved. But, aren't things like status word and control bits callee saved? If that's the case, it might require proper handling.
Ingo mentioned it in one of the parts you cut out of your reply:
Quoted 5 lines
and here is where thinking about threadlets as a function call and not as an asynchronous context helps alot: the classic gcc convention for FPU use & function calls should apply: gcc does not call an external function with an in-use FPU stack/register, it always neatly unuses it, as no FPU register is callee-saved, all are caller-saved.
The i386 psABI is ancient (i.e. it predates SSE, so no mention of the XMM or MXCSR registers) and a bit vague (no mention at all of the FP status word), but I'm fairly certain that Ingo is right.
Signature · 1 line
Nicholas Miell <[email protected]>
Quoted 8 lines · Nicholas Miell
Quoted 4 lines
as an asynchronous context helps alot: the classic gcc convention for FPU use & function calls should apply: gcc does not call an external function with an in-use FPU stack/register, it always neatly unuses it, as no FPU register is callee-saved, all are caller-saved.
The i386 psABI is ancient (i.e. it predates SSE, so no mention of the XMM or MXCSR registers) and a bit vague (no mention at all of the FP status word), but I'm fairly certain that Ingo is right.
The FPU status word *must* be saved, as the rounding behaviour and error mode bits are assumed to be preserved. Iow, yes, there is state which is required.
-ben
Signature · 2 lines
"Time is of no importance, Mr. President, only life is important." Don't Email: <[email protected]>.
Quoted 19 lines · Nicholas Miell
Quoted 9 lines · Davide Libenzi
Quoted 2 lines · Nicholas Miell
The point Ingo was making is that the x86 ABI already requires the FPU context to be saved before *all* function calls.
I've not seen that among Ingo's points, but yeah some status is caller saved. But, aren't things like status word and control bits callee saved? If that's the case, it might require proper handling.
Ingo mentioned it in one of the parts you cut out of your reply:
Quoted 5 lines
and here is where thinking about threadlets as a function call and not as an asynchronous context helps alot: the classic gcc convention for FPU use & function calls should apply: gcc does not call an external function with an in-use FPU stack/register, it always neatly unuses it, as no FPU register is callee-saved, all are caller-saved.
Quoted 3 lines
The i386 psABI is ancient (i.e. it predates SSE, so no mention of the XMM or MXCSR registers) and a bit vague (no mention at all of the FP status word), but I'm fairly certain that Ingo is right.
I'm not sure if that's the case. I'd be happy if it was, but I'm afraid it's not. Status word and control bits should not be changed from underneath userspace AFAIK. The ABI I remember tells me that those are callee saved. A quick gcc asm test tells me that too.
And assuming that's the case, why don't we have a smarter unlazy_fpu() then, that avoid FPU context sync if we're scheduled while inside a syscall (this is no different than an enter inside sys_async_exec - userspace should have taken care of it)?
IMO a syscall enter should not assume that userspace took care of saving the whole FPU context.
- Davide
Quoted 2 lines · Davide Libenzi
[...] Status word and control bits should not be changed from underneath userspace AFAIK. [...]
Note that the control bits do not just magically change during normal FPU use. It's a bit like sys_setsid()/iopl/etc., it makes little sense to change those per-thread anyway. This is a non-issue anyway - what is important is that the big bulk of 512 (or more) bytes of FPU state /are/ callee-saved (both on 32-bit and on 64-bit), hence there's no need to unlazy anything or to do expensive FPU state saves or other FPU juggling around threadlet (or even syslet) use.
Ingo
Quoted 5 lines · Ingo Molnar
Note that the control bits do not just magically change during normal FPU use. It's a bit like sys_setsid()/iopl/etc., it makes little sense to change those per-thread anyway. This is a non-issue anyway - what is important is that the big bulk of 512 (or more) bytes of FPU state /are/ callee-saved (both on 32-bit and on 64-bit), hence there's no need to
^---- caller-saved
Quoted 2 lines
unlazy anything or to do expensive FPU state saves or other FPU juggling around threadlet (or even syslet) use.
Quoted 5 lines · Ingo Molnar
Quoted 2 lines · Davide Libenzi
[...] Status word and control bits should not be changed from underneath userspace AFAIK. [...]
Quoted 7 lines
Note that the control bits do not just magically change during normal FPU use. It's a bit like sys_setsid()/iopl/etc., it makes little sense to change those per-thread anyway. This is a non-issue anyway - what is important is that the big bulk of 512 (or more) bytes of FPU state /are/ callee-saved (both on 32-bit and on 64-bit), hence there's no need to unlazy anything or to do expensive FPU state saves or other FPU juggling around threadlet (or even syslet) use.
Well, the unlazy/sync happen in any case later when we switch (given TS_USEDFPU set). We'd avoid a copy of it given the above conditions true. Wouldn't it makes sense to carry over only the status word and the control bits eventually?
Also, if the caller saves the whole context, and if we're scheduled while inside a system call (not totally unfrequent case), can't we implement a smarter unlazy_fpu that avoids fxsave during schedule-out and frstor after schedule-in (do not do stts on this condition, so the newly scheduled task don't get a fault at all)? If the above conditions are true (no need context-copy for new head in async_exec), this should be possible too.
- Davide
Quoted 1 line · Evgeniy Polyakov
Ingo, do you really think I will send mails with faked benchmarks? :))
I don't think he ever implied that. He was only suggesting that when you post benchmarks, and even more when you make claims based on benchmarks, you need to be extra carefull about what you measure. Otherwise the external view that you give to others does not look good. Kevent can be really faster than epoll, but if you post broken benchmarks (that can be, unrealiable HTTP loaders, broken server implemenations, etc..) and make claims based on that, the only effect that you have is to lose your point.
- Davide
Quoted 4 lines · Davide Libenzi
Quoted 1 line · Evgeniy Polyakov
Ingo, do you really think I will send mails with faked benchmarks? :))
Quoted 8 lines
I don't think he ever implied that. He was only suggesting that when you post benchmarks, and even more when you make claims based on benchmarks, you need to be extra carefull about what you measure. Otherwise the external view that you give to others does not look good. Kevent can be really faster than epoll, but if you post broken benchmarks (that can be, unrealiable HTTP loaders, broken server implemenations, etc..) and make claims based on that, the only effect that you have is to lose your point.
We seems to move far away from original topic - I never built any assumptions on top of kevent _performance_ - kevent is a logical extrapolation of the epoll, I only showed that event driven model can be fast and it outperforms threadlet one - after we changed topic we were unable to actually test threadlets in networking environment, since the only test I ran showed that threadlest do not reschedule at all, and Ingo's tests showed small number of reschedulings.
So, I only talked that kevent is superior compared to epoll because (and it is _main_ issue) of its ability to handle essentially any kind of events with very small overhead (the same as epoll has in struct file - list and spinlock) and without significant price of struct file binding to event.
I did not want and do not want to hurt anyone (even Ingo, although he is against kevent :), but my opinion is that thread moved from nice discussion about threads and events with jokes and fun into quite angry word throwings, and that is too good - let's make it fun again. I'm not a native english speaker (and do not use a dictionary), so it is quite possible that some my phrases were not exactly nice, but it was unintentional (at least not very) :)
Peace?
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 14 lines · Evgeniy Polyakov
Quoted 4 lines · Davide Libenzi
Quoted 1 line · Evgeniy Polyakov
Ingo, do you really think I will send mails with faked benchmarks? :))
Quoted 8 lines
I don't think he ever implied that. He was only suggesting that when you post benchmarks, and even more when you make claims based on benchmarks, you need to be extra carefull about what you measure. Otherwise the external view that you give to others does not look good. Kevent can be really faster than epoll, but if you post broken benchmarks (that can be, unrealiable HTTP loaders, broken server implemenations, etc..) and make claims based on that, the only effect that you have is to lose your point.
Quoted 5 lines
So, I only talked that kevent is superior compared to epoll because (and it is _main_ issue) of its ability to handle essentially any kind of events with very small overhead (the same as epoll has in struct file - list and spinlock) and without significant price of struct file binding to event.
You've to excuse me if my memory is bad, but IIRC the whole discussion and loong benchmark feast born with you throwing a benchmark at Ingo (with kevent showing a 1.9x performance boost WRT epoll), not with you making any other point.
As far as epoll not being able to handle other events. Said who? Of course, with zero modifications, you can handle zero additional events. With modifications, you can handle other events. But lets talk about those other events. The *only* kind of event that ppl (and being the epoll maintainer I tend to receive those requests) missed in epoll, was AIO events, That's the *only* thing that was missed by real life application developers. And if something like threadlets/syslets will prove effective, the gap is closed WRT that requirement.
Epoll handle already the whole class of pollable devices inside the kernel, and if you exclude block AIO, that's a pretty wide class already. The *existing* f_op->poll subsystem can be used to deliver events at the poll-head wakeup time (by using the "key" member of the poll callback), so that you don't even need the extra f_op->poll call to fetch events. And if you really feel raw about the single O(nready) loop that epoll currently does, a new epoll_wait2 (or whatever) API could be used to deliver the event directly into a userspace buffer [1], directly from the poll callback, w/out extra delivery loops (IRQ/event->epoll_callback->event_buffer).
[1] From the epoll callback, we cannot sleep, so it's gonna be either an mlocked userspace buffer, or some kernel pages mapped to userspace.
- Davide
Quoted 4 lines · Davide Libenzi
And if you really feel raw about the single O(nready) loop that epoll currently does, a new
epoll_wait2(or whatever) API could be used to deliver the event directly into a userspace buffer [1], directly from the poll callback, w/out extra delivery loops (IRQ/event->epoll_callback->event_buffer).
And if you ever wonder from where the "epoll" name came, it came from the old /dev/epoll. The epoll predecessor /dev/epoll, was adding plugs everywhere events where needed and was delivering those events in O(1) *directly* on a user visible (mmap'd) buffer, in a zero-copy fashion. The old /dev/epoll was faster the the current epoll, but the latter was chosen because despite being sloghtly slower, it had support for every pollable device, *without* adding more plugs into the existing code. Performance and code maintainance are not to be taken disjointly whenever you evaluate a solution. That's the reason I got excited about this new generic AIO slution.
- Davide
Quoted 22 lines · Davide Libenzi
Quoted 14 lines · Evgeniy Polyakov
Quoted 4 lines · Davide Libenzi
Quoted 1 line · Evgeniy Polyakov
Ingo, do you really think I will send mails with faked benchmarks? :))
Quoted 8 lines
I don't think he ever implied that. He was only suggesting that when you post benchmarks, and even more when you make claims based on benchmarks, you need to be extra carefull about what you measure. Otherwise the external view that you give to others does not look good. Kevent can be really faster than epoll, but if you post broken benchmarks (that can be, unrealiable HTTP loaders, broken server implemenations, etc..) and make claims based on that, the only effect that you have is to lose your point.
Quoted 5 lines
So, I only talked that kevent is superior compared to epoll because (and it is _main_ issue) of its ability to handle essentially any kind of events with very small overhead (the same as epoll has in struct file - list and spinlock) and without significant price of struct file binding to event.
Quoted 4 lines
You've to excuse me if my memory is bad, but IIRC the whole discussion and loong benchmark feast born with you throwing a benchmark at Ingo (with kevent showing a 1.9x performance boost WRT epoll), not with you making any other point.
So, how does it sound?
"Threadlets are bad for IO because kevent is 2 times faster than epoll?"
I said threadlets are bad for IO (and we agreed that both approaches shouldbe usedfor the maximum performance) because of rescheduling overhead - tasks are quite heavy structuresa to move around - even pt_regs copy takes more than event structure, but not because there is something in other galaxy which might work faster than another something in another galaxy. That was stupid even to think about that.
Quoted 9 lines
As far as epoll not being able to handle other events. Said who? Of course, with zero modifications, you can handle zero additional events. With modifications, you can handle other events. But lets talk about those other events. The *only* kind of event that ppl (and being the epoll maintainer I tend to receive those requests) missed in epoll, was AIO events, That's the *only* thing that was missed by real life application developers. And if something like threadlets/syslets will prove effective, the gap is closed WRT that requirement.
Epoll handle already the whole class of pollable devices inside the
Quoted 8 lines
kernel, and if you exclude block AIO, that's a pretty wide class already. The *existing*
f_op->pollsubsystem can be used to deliver events at the poll-head wakeup time (by using the "key" member of the poll callback), so that you don't even need the extraf_op->pollcall to fetch events. And if you really feel raw about the single O(nready) loop that epoll currently does, a newepoll_wait2(or whatever) API could be used to deliver the event directly into a userspace buffer [1], directly from the poll callback, w/out extra delivery loops (IRQ/event->epoll_callback->event_buffer).
Signals, futexes, timers and userspace events I was requested to add into kevent, so far only futexes are missed because I was asked to freeze development so other hackers could check the project.
Quoted 3 lines
[1] From the epoll callback, we cannot sleep, so it's gonna be either an mlocked userspace buffer, or some kernel pages mapped to userspace.
Callbacks never sleep - they add event into list just like current implementation (maybe some lock must be changed from mutex to spinlock, I do not rememeber), main problem is binding to the file structure, which is heavy.
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 8 lines · Evgeniy Polyakov
Quoted 4 lines
You've to excuse me if my memory is bad, but IIRC the whole discussion and loong benchmark feast born with you throwing a benchmark at Ingo (with kevent showing a 1.9x performance boost WRT epoll), not with you making any other point.
So, how does it sound?
"Threadlets are bad for IO because kevent is 2 times faster than epoll?"
Quoted 6 lines
I said threadlets are bad for IO (and we agreed that both approaches shouldbe usedfor the maximum performance) because of rescheduling overhead - tasks are quite heavy structuresa to move around - even
pt_regscopy takes more than event structure, but not because there is something in other galaxy which might work faster than another something in another galaxy. That was stupid even to think about that.
Evgeny, other folks on this thread read what you said, so let's not drag this over.
Quoted 5 lines
Quoted 4 lines
And if you really feel raw about the single O(nready) loop that epoll currently does, a new
epoll_wait2(or whatever) API could be used to deliver the event directly into a userspace buffer [1], directly from the poll callback, w/out extra delivery loops (IRQ/event->epoll_callback->event_buffer).
Quoted 7 lines
Quoted 2 lines
[1] From the epoll callback, we cannot sleep, so it's gonna be either an mlocked userspace buffer, or some kernel pages mapped to userspace.
Callbacks never sleep - they add event into list just like current implementation (maybe some lock must be changed from mutex to spinlock, I do not rememeber), main problem is binding to the file structure, which is heavy.
I was referring to dropping an event directly to a userspace buffer, from the poll callback. If pages are not there, you might sleep, and you can't since the wakeup function holds a spinlock on the waitqueue head while looping through the waiters to issue the wakeup. Also, you don't know from where the poll wakeup is called.
File binding heavy? The first, and by *far* biggest, source of events inside an event collector, of someone that cares about scalability, are sockets. And those are already files. Second would be AIO, and those (if performance figures agrees) can be hosted inside syslets/threadlets. Then you fall into the no-care category, where the extra 100 bytes do not make a case against the ability of using it with an existing POSIX infrastructure (poll/select).
BTW, Linus made a signalfd sketch code time ago, to deliver signals to an fd. Code remained there and nobody cared. Question: Was it because
1) it had file bindings or 2) because nobody really cared to deliver signals to an event collector?
And *if* later requirements come, you don't need to change the API by adding an XXEVENT_SIGNAL_ADD or XXEVENT_TIMER_ADD, or creating a new XXEVENT-only submission structure. You create an API that automatically makes that new abstraction work with POSIX poll/select, and you get epoll support for free. Without even changing a bit in the epoll API.
- Davide
Quoted 17 lines · Davide Libenzi
Quoted 8 lines · Evgeniy Polyakov
Quoted 4 lines
You've to excuse me if my memory is bad, but IIRC the whole discussion and loong benchmark feast born with you throwing a benchmark at Ingo (with kevent showing a 1.9x performance boost WRT epoll), not with you making any other point.
So, how does it sound?
"Threadlets are bad for IO because kevent is 2 times faster than epoll?"Quoted 6 lines
I said threadlets are bad for IO (and we agreed that both approaches shouldbe usedfor the maximum performance) because of rescheduling overhead - tasks are quite heavy structuresa to move around - even
pt_regscopy takes more than event structure, but not because there is something in other galaxy which might work faster than another something in another galaxy. That was stupid even to think about that.
Quoted 2 lines
Evgeny, other folks on this thread read what you said, so let's not drag this over.
Sure, I was wrong to start this again, but try to get my position - I really tired from trying to prove that I'm not a camel just because we had some misunderstanding at the start.
I do think that threadlets are relly cool solution and are indeed very good approach for majority of the parallel processing, but my point is still that it is not a perfect solution for all tasks.
Just to draw a line: kevent example is extrapolation of what can be achieved with event-driven model, but that does not mean that it must be _only_ used for AIO model - threadlets _and_ event driven model (yes, I accepted Ingo's point about its declining) is the best solution.
Quoted 13 lines
Quoted 5 lines
Quoted 4 lines
And if you really feel raw about the single O(nready) loop that epoll currently does, a new
epoll_wait2(or whatever) API could be used to deliver the event directly into a userspace buffer [1], directly from the poll callback, w/out extra delivery loops (IRQ/event->epoll_callback->event_buffer).Quoted 7 lines
Quoted 2 lines
[1] From the epoll callback, we cannot sleep, so it's gonna be either an mlocked userspace buffer, or some kernel pages mapped to userspace.
Callbacks never sleep - they add event into list just like current implementation (maybe some lock must be changed from mutex to spinlock, I do not rememeber), main problem is binding to the file structure, which is heavy.
Quoted 5 lines
I was referring to dropping an event directly to a userspace buffer, from the poll callback. If pages are not there, you might sleep, and you can't since the wakeup function holds a spinlock on the waitqueue head while looping through the waiters to issue the wakeup. Also, you don't know from where the poll wakeup is called.
Ugh, no, that is very limited solution - memory must be either pinned (which leads to dos and limited ring buffer), or callback must sleep. Actually in any way there _must_ exist a queue - if ring buffer is full event is not allowed to be dropped - it must be stored in some other place, for example in queue from where entries will be read (copied) which ring buffer will have entries (that is how it is implemented in kevent at least).
Quoted 7 lines
File binding heavy? The first, and by *far* biggest, source of events inside an event collector, of someone that cares about scalability, are sockets. And those are already files. Second would be AIO, and those (if performance figures agrees) can be hosted inside syslets/threadlets. Then you fall into the no-care category, where the extra 100 bytes do not make a case against the ability of using it with an existing POSIX infrastructure (poll/select).
Well, sockets are the files indeed, and sockets already are perfectly handled by epoll - but there are other users of petential interace - and it must be designed to scale in _any_ situation very well. Even if we right now do not have problems with some types of events, we must scale with any new one.
Quoted 9 lines
BTW, Linus made a signalfd sketch code time ago, to deliver signals to an fd. Code remained there and nobody cared. Question: Was it because
1) it had file bindings or 2) because nobody really cared to deliver signals to an event collector?
And *if* later requirements come, you don't need to change the API by adding anXXEVENT_SIGNAL_ADDorXXEVENT_TIMER_ADD, or creating a new XXEVENT-only submission structure. You create an API that automatically makes that new abstraction work with POSIX poll/select, and you get epoll support for free. Without even changing a bit in the epoll API.
Well, we get epoll support for free, but we need to create tons of other interfaces and infrastructure for kernel users, and we need to change userspace anyway.
But epoll support requires to have quite heavy bindings to file structure, so why don't we want to design new interface (since we need to change userspace anyway) so that it could allow to scale and be very memory optimized from the beginning?
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · Evgeniy Polyakov
Quoted 5 lines
I was referring to dropping an event directly to a userspace buffer, from the poll callback. If pages are not there, you might sleep, and you can't since the wakeup function holds a spinlock on the waitqueue head while looping through the waiters to issue the wakeup. Also, you don't know from where the poll wakeup is called.
Quoted 7 lines
Ugh, no, that is very limited solution - memory must be either pinned (which leads to dos and limited ring buffer), or callback must sleep. Actually in any way there _must_ exist a queue - if ring buffer is full event is not allowed to be dropped - it must be stored in some other place, for example in queue from where entries will be read (copied) which ring buffer will have entries (that is how it is implemented in kevent at least).
I was not advocating for that, if you read carefully. The fact that epoll does not do that, should be a clear hint. The old /dev/epoll IIRC was only 10% faster than the current epoll under an *heavy* event frequency micro-bench like pipetest (and that version of epoll did not have the single pass over the ready set optimization). And /dev/epoll was delivering events *directly* on userspace visible (mmaped) memory in a zero-copy fashion.
Quoted 10 lines
Quoted 9 lines
BTW, Linus made a signalfd sketch code time ago, to deliver signals to an fd. Code remained there and nobody cared. Question: Was it because
1) it had file bindings or 2) because nobody really cared to deliver signals to an event collector?
And *if* later requirements come, you don't need to change the API by adding anXXEVENT_SIGNAL_ADDorXXEVENT_TIMER_ADD, or creating a new XXEVENT-only submission structure. You create an API that automatically makes that new abstraction work with POSIX poll/select, and you get epoll support for free. Without even changing a bit in the epoll API.
Quoted 3 lines
Well, we get epoll support for free, but we need to create tons of other interfaces and infrastructure for kernel users, and we need to change userspace anyway.
Those *other* (tons?!?) interfaces can be created *when* the need comes (see Linus signalfd [1] example to show how urgent that was). *When* the need comes, they will work with existing POSIX interfaces, without requiring your own just-another event interface. Those other interfaces could also be more easily adopted by other Unix cousins, because of the fact that they rely on existing POSIX interfaces. One of the reason about the Unix file abstraction interfaces, is that you do *not* have to plan and bloat interfaces before. As long as your new abstraction behave in a file-fashion, it can be automatically used with existing interfaces. And you create them *when* the need comes.
[1] That was like 100 lines of code or so. See here:
http://tinyurl.com/3yuna5
- Davide
Quoted 10 lines · Davide Libenzi
Those *other* (tons?!?) interfaces can be created *when* the need comes (see Linus signalfd [1] example to show how urgent that was). *When* the need comes, they will work with existing POSIX interfaces, without requiring your own just-another event interface. Those other interfaces could also be more easily adopted by other Unix cousins, because of the fact that they rely on existing POSIX interfaces. One of the reason about the Unix file abstraction interfaces, is that you do *not* have to plan and bloat interfaces before. As long as your new abstraction behave in a file-fashion, it can be automatically used with existing interfaces. And you create them *when* the need comes.
Now, if you don't mind, my spare time is really limited and I prefer to spend it looking at stuff the topic of this thread talks about. Even because the whole epoll/kevent discussion is heavily dependent on the fact that syslets/threadlets will or will not result a viable method for generic AIO. Savvy?
- Davide
Quoted 8 lines · Davide Libenzi
<snip>
Those *other* (tons?!?) interfaces can be created *when* the need comes (see Linus signalfd [1] example to show how urgent that was). *When* the need comes, they will work with existing POSIX interfaces, without requiring your own just-another event interface. Those other interfaces could also be more easily adopted by other Unix cousins, because of the fact that they rely on existing POSIX interfaces.
Please stop with this crap, this chicken or the egg argument of yours is utter BULLSHIT! Just because Linux doesn't have a decent kernel event notification mechanism it does not mean that users don't need. Nobody cared about Linus's
signalfd because it wasn't mainline.
Look at any event notification libraries out there, it makes me sick how much kludge they have to go thru to get near the same functionality of kqueue on Linux.
Solaris has the Event Ports mechanism since 2003. FreeBSD, NetBSD, OpenBSD and Mac OS X support kqueue since around 2000. Windows has had event notification for ages now. These _facilities_ are all widely used, given the platforms
popularity.
So here we are, 2007. epoll() works with files, pipes, sockets, inotify and anything
pollable (file descriptors) but aio, timers, signals and user-defined event. Can we
please get those working with epoll ? Something as simple as:
struct epoll_event ev;
ev.events = EV_TIMER | EPOLLONESHOT;
ev.data.u64 = 1000; /* timeout */
epoll_ctl(epfd, EPOLL_CTL_ADD, 0 /* ignored */, &ev);
or
struct sigevent ev;
ev.sigev_notify = SIGEV_EPOLL;
ev.sigev_signo = epfd;
ev.sigev_value = &ev;
timer_create(CLOCK_MONOTONIC, &ev, &timerid);
AIO:
struct sigevent ev;
int fd = io_setup(..); /* oh boy, I wish... but it works */
ev.events = EV_AIO | EPOLLONESHOT;
/* event.data.ptr returns pointer to the iocb */epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &ev);
or
struct iocb iocb;
iocb.aio_fildes = fileno(stdin);
iocb.aio_lio_opcode = IO_CMD_PREAD;
iocb.c.notify = IO_NOTIFY_EPOLL; /* __pad3/4 */
Would this be acceptable? Can we finally move on?
--
Kirk Kuchov
Quoted 5 lines · Kirk Kuchov
So here we are, 2007.
epoll()works with files, pipes, sockets, inotify and anything pollable (file descriptors) but aio, timers, signals and user-defined event. Can we please get those working with epoll ? Something as simple as:[code snipped]
Would this be acceptable? Can we finally move on?
Well, even this far into 2.6, Linus' patch from 2003 still (mostly) applies; the maintenance cost for this kind of code is virtually zilch. If it matters that much to you clean it up and make it apply; add an alarmfd() syscall (another 100 lines of code at most?) and make a "read" return an architecture-independent siginfo-like structure and submit it for inclusion. Adding epoll() support for random objects is as simple as a 75-line object-filesystem and a 25-line syscall to return an FD to a new inode. Have fun! Go wild! Something this trivially simple could probably spend a week in -mm and go to linus for 2.6.22.
Cheers,
Kyle Moffett
Quoted 10 lines · Kyle Moffett
Well, even this far into 2.6, Linus' patch from 2003 still (mostly) applies; the maintenance cost for this kind of code is virtually zilch. If it matters that much to you clean it up and make it apply; add an
alarmfd()syscall (another 100 lines of code at most?) and make a "read" return an architecture-independent siginfo-like structure and submit it for inclusion. Addingepoll()support for random objects is as simple as a 75-line object-filesystem and a 25- line syscall to return an FD to a new inode. Have fun! Go wild! Something this trivially simple could probably spend a week in -mm and go to linus for 2.6.22.
Or, if you want to do slightly more work and produce something a great deal more useful, you could implement additional netlink address families for additional "event" sources. The socket - setsockopt - bind - sendmsg/recvmsg sequence is a well understood and well documented UNIX paradigm for multiplexing non-blocking I/O to many destinations over one socket. Everyone who has read Stevens is familiar with the basic UDP and "fd open server" techniques, and if you look at Linux's IP_PKTINFO and NETLINK_W1 (bravo, Evgeniy!) you'll see how easily they could be extended to file AIO and other kinds of event sources.
For file AIO, you might have the application open one AIO socket per mount point, open files indirectly via the SCM_RIGHTS mechanism, and submit/retire read/write requests via sendmsg/recvmsg with ancillary data consisting of an lseek64 tuple and a user-provided cookie. Although the process still has to have one fd open per actual open file (because trying to authenticate file accesses without opening fds is madness), the only fds it has to manipulate directly are those representing entire pools of outstanding requests. This is usually a small enough set that select() will do just fine, if you're careful with fd allocation. (You can simply punt indirectly opened fds up to a high numerical range, where they can't be accessed directly from userspace but still make fine cookies for use in lseek64 tuples within cmsg headers).
The same basic approach will work for timers, signals, and just about any other event source. Userspace is of course still stuck doing its own state machines / thread scheduling / however you choose to think of it. But all the important activity goes through socketcall(), and the data and control parameters are all packaged up into a struct msghdr instead of the bare buffer pointers of read/write. So if someone else does come along later and design an ultralight threading mechanism that isn't a total botch, the actual data paths won't need much rework; the exception handling will just get a lot simpler.
Cheers,
- Michael
Quoted 10 lines · Kirk Kuchov
Quoted 8 lines · Davide Libenzi
<snip>
Those *other* (tons?!?) interfaces can be created *when* the need comes (see Linus signalfd [1] example to show how urgent that was). *When* the need comes, they will work with existing POSIX interfaces, without requiring your own just-another event interface. Those other interfaces could also be more easily adopted by other Unix cousins, because of the fact that they rely on existing POSIX interfaces.
Quoted 2 lines
Please stop with this crap, this chicken or the egg argument of yours is utter BULLSHIT!
Wow, wow, fella! You _deinitely_ cannot afford rudeness here. You started bad, and you end even worse. By listing a some APIs that will work only with epoll. As I said already, and as it was listed in the thread I posted the link, something like:
int signalfd(...); // Linus initial interface would be perfectly fine int timerfd(...); // Open ... int eventfd(...); // [1]
Will work *even* with standard POSIX select/poll. 95% or more of the software does not have scalability issues, and select/poll are more portable and easy to use for simple stuff. On top of that, as I already said, they are *confined* interfaces that could be more easily adopted by other Unixes (if they are 100-200 lines on Linux, don't expect them to be a lot more on other Unixes) [2]. We *already* have the infrastructure inside Linux to deliver events (f_op->poll subsystem), how about we use that instead of just-another way? [3]
As for why common abstractions like file are a good thing, think about why having "/dev/null" is cleaner that having a special plug DEVNULL_FD fd value to be plugged everywhere, or why I can use find/grep/cat/echo/... to look/edit at my configuration inside /proc, instead of using a frigging registry editor. But here the list could be almost endless. And please don't start the, they don't scale or they need heavy file binding tossfeast. They scale as well as the interface that will receive them (poll, select, epoll). Heavy file binding what? 100 or so bytes for the struct file? How many signal/timer fd are you gonna have? Like 100K? Really moot argument when opposed to the benefit of being compatible with existing POSIX interfaces and being more Unix friendly.
As for the AIO stuff, if threadlets/syslets will prove effective, you can host an epoll_wait over a syslet/threadlet. Or, if the 3 lines of userspace code needed to do that, fall inside your definition of "kludge", we can even find a way to bridge the two.
Now, how about we focus on the topic of this thread?
[1] This could be an idea. People already uses pipes for this, but pipes has some memory overhead inside the kernel (plus use two fds) that could, if really felt necessary, be avoided.
[2] This is how those kind of interfaces should be designed. Modular, re-usable, file-based interfaces, whose acceptance is not linked into slurping-in a whole new interface with tenths of sub, interface-only, objects. And from this POV, epoll is the friendlier.
[3] Notice the similarity between threadlets/syslets and epoll? They enable pretty darn good scalability, with *existing* infrastructure, and w/out special ad-hoc code to be plugged everywhere. This translate directly in easier to maintain code.
- Davide
Quoted 12 lines · Davide Libenzi
Quoted 10 lines · Kirk Kuchov
Quoted 8 lines · Davide Libenzi
<snip>
Those *other* (tons?!?) interfaces can be created *when* the need comes (see Linus signalfd [1] example to show how urgent that was). *When* the need comes, they will work with existing POSIX interfaces, without requiring your own just-another event interface. Those other interfaces could also be more easily adopted by other Unix cousins, because of the fact that they rely on existing POSIX interfaces.
Quoted 4 lines
Quoted 2 lines
Please stop with this crap, this chicken or the egg argument of yours is utter BULLSHIT!
Wow, wow, fella! You _deinitely_ cannot afford rudeness here.
I don't give a shit.
Quoted 8 lines
You started bad, and you end even worse. By listing a some APIs that will work only with epoll. As I said already, and as it was listed in the thread I posted the link, something like:
int signalfd(...); // Linus initial interface would be perfectly fine int timerfd(...); // Open ... int eventfd(...); // [1]
Quoted 8 lines
Will work *even* with standard POSIX select/poll. 95% or more of the software does not have scalability issues, and select/poll are more portable and easy to use for simple stuff. On top of that, as I already said, they are *confined* interfaces that could be more easily adopted by other Unixes (if they are 100-200 lines on Linux, don't expect them to be a lot more on other Unixes) [2]. We *already* have the infrastructure inside Linux to deliver events (
f_op->pollsubsystem), how about we use that instead of just-another way? [3]
Man you're so full of shit, your eyes are brown. NOBODY cares about select/poll or that the interfaces are going to be adopted by other Unixes. This issue has already been solved by then YEARS ago.
What I want (and a ton of other users) is a SIMPLE and generic way to receive events from _MULTIPLE_multiple sources. I don't care about kernel-level portability, easiness or whatever, the linux kernel developers are good at not knowing what their users want.
Quoted 3 lines
As for why common abstractions like file are a good thing, think about why having "
/dev/null" is cleaner that having a special plugDEVNULL_FDfd value to be plugged everywhere,
This is a stupid comparaison. By your logic we should also have /dev/stdin, /dev/stdout and /dev/stderr.
Quoted 3 lines
or why I can use find/grep/cat/echo/... to
look/edit at my configuration inside /proc, instead of using a frigging registry editor.
Yet another stupid comparaison, /proc is a MESS! Almost as worse as the registry. Linux now has three pieces of crap for configuration/information: /proc, sysfs and sysctl. Nobody knows exactly what should go into each one of those. Crap design at it's best.
Quoted 7 lines
But here the list could be almost endless.
And please don't start the, they don't scale or they need heavy file binding tossfeast. They scale as well as the interface that will receive them (poll, select, epoll). Heavy file binding what? 100 or so bytes for the struct file? How many signal/timer fd are you gonna have? Like 100K? Really moot argument when opposed to the benefit of being compatible with existing POSIX interfaces and being more Unix friendly.
So why the HELL don't we have those yet? Why haven't you designed epoll with those in mind? Why don't you back your claims with patches? (I'm not a kernel developer.)
Quoted 4 lines
As for the AIO stuff, if threadlets/syslets will prove effective, you can host an
epoll_waitover a syslet/threadlet. Or, if the 3 lines of userspace code needed to do that, fall inside your definition of "kludge", we can even find a way to bridge the two.
I don't care about threadlets in this context, I just want to wait for EVENTS from MULTIPLE sources WITHOUT mixing signals and other crap. Your arrogance is amusing, stop pushing narrow-minded beliefs down the throats of all Linux users. Kqueue, event ports, WaitForMultipleObjects, epoll with multiple sources. That's what users want, not yet another syscall/whatever hack.
Quoted 5 lines
Now, how about we focus on the topic of this thread?
[1] This could be an idea. People already uses pipes for this, but pipes has some memory overhead inside the kernel (plus use two fds) that could, if really felt necessary, be avoided.
Yet another hack!! 64kiB of space just to push some user events around. Great idea!
Quoted 5 lines
[2] This is how those kind of interfaces should be designed. Modular, re-usable, file-based interfaces, whose acceptance is not linked into slurping-in a whole new interface with tenths of sub, interface-only, objects. And from this POV, epoll is the friendlier.
Who said I want yet another interface? I just fucking want to receive events from MULTIPLE sources through epoll. With or without a fd! My anger and frustration is that we can get past this SIMPLE need!
Quoted 4 lines
[3] Notice the similarity between threadlets/syslets and epoll? They enable pretty darn good scalability, with *existing* infrastructure, and w/out special ad-hoc code to be plugged everywhere. This translate directly in easier to maintain code.
Easier for kernel developers, of cource. <sarcasm> Who cares? Fuck the users. <sarcasm>
--
Kirk Kuchov
Quoted 1 line · Kirk Kuchov
I don't give a shit.
Here's another good use of /dev/null:
*PLONK*
- Davide
Kirk Kuchov wrote:
[snip]
Quoted 4 lines
This is a stupid comparaison. By your logic we should also have
/dev/stdin,/dev/stdoutand/dev/stderr.
Well, as a matter of fact (on my system):
# ls -l /dev/std* lrwxrwxrwx 1 root root 4 Feb 1 2006 /dev/stderr -> fd/2 lrwxrwxrwx 1 root root 4 Feb 1 2006 /dev/stdin -> fd/0 lrwxrwxrwx 1 root root 4 Feb 1 2006 /dev/stdout -> fd/1
Please don't bother to respond to this mail, I just saw that you apparently needed the info.
Magnus
P.S.: *PLONK*
Quoted 6 lines
Quoted 3 lines
As for why common abstractions like file are a good thing, think about why having "
/dev/null" is cleaner that having a special plugDEVNULL_FDfd value to be plugged everywhere,This is a stupid comparaison. By your logic we should also have
/dev/stdin,/dev/stdoutand/dev/stderr.
Bzzt, wrong. We have them.
pavel@amd:~$ ls -al /dev/std* lrwxrwxrwx 1 root root 4 Nov 12 2003 /dev/stderr -> fd/2 lrwxrwxrwx 1 root root 4 Nov 12 2003 /dev/stdin -> fd/0 lrwxrwxrwx 1 root root 4 Nov 12 2003 /dev/stdout -> fd/1 pavel@amd:~$ ls -al /proc/self/fd total 0 dr-x------ 2 pavel users 0 Mar 6 09:18 . dr-xr-xr-x 4 pavel users 0 Mar 6 09:18 .. lrwx------ 1 pavel users 64 Mar 6 09:18 0 -> /dev/ttyp2 lrwx------ 1 pavel users 64 Mar 6 09:18 1 -> /dev/ttyp2 lrwx------ 1 pavel users 64 Mar 6 09:18 2 -> /dev/ttyp2 lr-x------ 1 pavel users 64 Mar 6 09:18 3 -> /proc/2299/fd pavel@amd:~$
Quoted 11 lines
Quoted 7 lines
But here the list could be almost endless.
And please don't start the, they don't scale or they need heavy file binding tossfeast. They scale as well as the interface that will receive them (poll, select, epoll). Heavy file binding what? 100 or so bytes for the struct file? How many signal/timer fd are you gonna have? Like 100K? Really moot argument when opposed to the benefit of being compatible with existing POSIX interfaces and being more Unix friendly.So why the HELL don't we have those yet? Why haven't you designed epoll with those in mind? Why don't you back your claims with patches? (I'm not a kernel developer.)
Either stop flaming kernel developers or become one. It is that simple.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 9 lines · Pavel Machek
Quoted 6 lines
Quoted 3 lines
As for why common abstractions like file are a good thing, think about why having "
/dev/null" is cleaner that having a special plugDEVNULL_FDfd value to be plugged everywhere,This is a stupid comparaison. By your logic we should also have
/dev/stdin,/dev/stdoutand/dev/stderr.Bzzt, wrong. We have them.
Quoted 13 lines
pavel@amd:~$ ls -al /dev/std* lrwxrwxrwx 1 root root 4 Nov 12 2003 /dev/stderr -> fd/2 lrwxrwxrwx 1 root root 4 Nov 12 2003 /dev/stdin -> fd/0 lrwxrwxrwx 1 root root 4 Nov 12 2003 /dev/stdout -> fd/1 pavel@amd:~$ ls -al /proc/self/fd total 0 dr-x------ 2 pavel users 0 Mar 6 09:18 . dr-xr-xr-x 4 pavel users 0 Mar 6 09:18 .. lrwx------ 1 pavel users 64 Mar 6 09:18 0 -> /dev/ttyp2 lrwx------ 1 pavel users 64 Mar 6 09:18 1 -> /dev/ttyp2 lrwx------ 1 pavel users 64 Mar 6 09:18 2 -> /dev/ttyp2 lr-x------ 1 pavel users 64 Mar 6 09:18 3 -> /proc/2299/fd pavel@amd:~$
I don't believe I'm wasting my time explaining this. They don't exist as /dev/null, they are just fucking _LINKS_. I could even "ln -s /proc/self/fd/0 sucker". A real /dev/stdout can/could even exist, but that's not the point!
It remains a stupid comparison because /dev/stdin/stderr/whatever "must" be plugged, else how could a process write to stdout/stderr that it coud'nt open it ? The way things are is not because it's cleaner to have it as a file but because it's the only sane way. /dev/null is not a must have, it's mainly used for redirecting purposes. A sys_nullify(fileno(stdout)) would rule out almost any use of /dev/null.
Quoted 12 lines
Quoted 12 lines
Quoted 11 lines
As for why common abstractions like file are a good thing, think about why having "
/dev/null" is cleaner that having a special plugDEVNULL_FDfd value to be plugged everywhere,But here the list could be almost endless.
And please don't start the, they don't scale or they need heavy file binding tossfeast. They scale as well as the interface that will receive them (poll, select, epoll). Heavy file binding what? 100 or so bytes for the struct file? How many signal/timer fd are you gonna have? Like 100K? Really moot argument when opposed to the benefit of being compatible with existing POSIX interfaces and being more Unix friendly.
Quoted 7 lines
Quoted 3 lines
So why the HELL don't we have those yet? Why haven't you designed epoll with those in mind? Why don't you back your claims with patches? (I'm not a kernel developer.)
Either stop flaming kernel developers or become one. It is that simple.
If I were to become a kernel developer I would stick with FreeBSD. At least they have kqueue for about seven years now.
--
Kirk Kuchov
Quoted 5 lines · Kirk Kuchov
I don't believe I'm wasting my time explaining this. They don't exist as
/dev/null, they are just fucking _LINKS_. I could even "ln -s/proc/self/fd/0sucker". A real/dev/stdoutcan/could even exist, but that's not the point!
Actually, one large reason for /proc/self/ existing is exactly /dev/stdin and friends.
And yes, /proc/self looks like a link too, but that doesn't change the fact that it's a very special file. No different from /dev/null or friends.
Linus
Quoted 2 lines · Kirk Kuchov
I don't believe I'm wasting my time explaining this. They don't exist as
/dev/null, they are just fucking _LINKS_.
[...]
Quoted 5 lines
Quoted 2 lines
Either stop flaming kernel developers or become one. It is that simple.
If I were to become a kernel developer I would stick with FreeBSD. [...]
Hey, really, this is an excellent idea: what a boon you could become to FreeBSD, again! How much they must be longing for your insightful feedback, how much they must be missing your charming style and tactful approach! I bet they'll want to print your mails out, frame them and hang them over their fireplace, to remember the good old days on cold snowy winter days, with warmth in their hearts! Please?
Ingo
Quoted 12 lines · Ingo Molnar
Quoted 2 lines · Kirk Kuchov
I don't believe I'm wasting my time explaining this. They don't exist as
/dev/null, they are just fucking _LINKS_.[...]
Quoted 5 lines
Quoted 2 lines
Either stop flaming kernel developers or become one. It is that simple.
If I were to become a kernel developer I would stick with FreeBSD. [...]
Quoted 7 lines
Hey, really, this is an excellent idea: what a boon you could become to FreeBSD, again! How much they must be longing for your insightful feedback, how much they must be missing your charming style and tactful approach! I bet they'll want to print your mails out, frame them and hang them over their fireplace, to remember the good old days on cold snowy winter days, with warmth in their hearts! Please?
http://www.totallytom.com/thecureforgayness.html
--
Kirk Kuchov
Quoted 21 lines · Kirk Kuchov
Quoted 12 lines · Ingo Molnar
Quoted 2 lines · Kirk Kuchov
I don't believe I'm wasting my time explaining this. They don't exist as
/dev/null, they are just fucking _LINKS_.[...]
Quoted 5 lines
Quoted 2 lines
Either stop flaming kernel developers or become one. It is that simple.
If I were to become a kernel developer I would stick with FreeBSD. [...]
Quoted 7 lines
Hey, really, this is an excellent idea: what a boon you could become to FreeBSD, again! How much they must be longing for your insightful feedback, how much they must be missing your charming style and tactful approach! I bet they'll want to print your mails out, frame them and hang them over their fireplace, to remember the good old days on cold snowy winter days, with warmth in their hearts! Please?
Quoted 1 line
Dude, get a life. But more importantly, go waste somebody elses time instead of lkml's.
Signature · 1 line
Jens Axboe, updating killfile
Quoted 21 lines · Kirk Kuchov
Quoted 12 lines · Ingo Molnar
Quoted 2 lines · Kirk Kuchov
I don't believe I'm wasting my time explaining this. They don't exist as
/dev/null, they are just fucking _LINKS_.[...]
Quoted 5 lines
Quoted 2 lines
Either stop flaming kernel developers or become one. It is that simple.
If I were to become a kernel developer I would stick with FreeBSD. [...]
Quoted 7 lines
Hey, really, this is an excellent idea: what a boon you could become to FreeBSD, again! How much they must be longing for your insightful feedback, how much they must be missing your charming style and tactful approach! I bet they'll want to print your mails out, frame them and hang them over their fireplace, to remember the good old days on cold snowy winter days, with warmth in their hearts! Please?
Quoted 1 line
Fonts are a bit bad in my browser :)
Kirk, I understand your frustration - yes, Linux is not the perfect place to include startups ideas, and yes it lacks some features modern (or old) systems support for years, but things change with time.
I posted a patch which allows to poll for signals, it can be trivially adopted to support timers and essentially any other events. Kevent did that too, but some things are just too radical for immediate support, especially when majority of users do not require additional functionality.
People do work, and a lot of them do really good work, so no need for rude talks about how things are bad. Things change - even I support that, although kevent ignorance should put me into the first line with you :)
Be good, and be cool.
Quoted 2 lines
--
Kirk Kuchov
Signature · 1 line
Evgeniy Polyakov
Quoted 13 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
I also changed client socket to nonblocking mode with the same result in epoll server. If you will find it broken, please send me corrected to test too.
this line in
evserver_kevent.clooks a bit fishy:err = recv(s, buf, 100, 0);because on the
evserver_epoll.cside the following is done:
Quoted 8 lines
err = recv(s, buf, 4096, 0);now, for 'ab', the request size is 76 bytes, so it should fit fine functionality-wise. But, the TCP stack might decide differently of whether to return with a partial packet depending on how much data is requested. I dont know whether it actually makes a difference in the TCP flow decisions, and whether it makes a performance difference in your test, but safest would be to use 4096 in both cases.
Well, that would be quite strange - as far as I known linux network stack (for which kevent was originally created to support network AIO), there should not be any difference.
Anyway, I've reran the test with the same values:
# ab -c8000 -n80000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.0.48 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.27 Server Hostname: 192.168.0.48 Server Port: 80
Document Path: / Document Length: 3521 bytes
Concurrency Level: 8000 Time taken for tests: 18.398381 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 338738048 bytes HTML transferred: 308031164 bytes Requests per second: 4348.21 [#/sec] (mean) Time per request: 1839.838 [ms] (mean) Time per request: 0.230 [ms] (mean, across all concurrent
requests)
Transfer rate: 17979.73 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 148 795 196.9 808 3599 Processing: 824 882 39.7 878 986 Waiting: 59 426 212.6 423 914
Total: 1073 1678 200.8 1673 4579
Percentage of the requests served within a certain time (ms)
50% 1673 66% 1674 75% 1678 80% 1686 90% 1852 95% 1861 98% 1864 99% 1865
100% 4579 (longest request)
Essentially the same result (in limits of some inaccuracy).
Quoted 3 lines
in general, please make sure the exact same system calls are done in the client function. (except of course for the event queueing syscalls themselves)
Yes, that should be done of course.
I even have a plan to create the same binary for both, but have also in plans to turn some kevent optimization (mainly readiness-on-submit, when requested event (secv/send/anything) is ready immediately - kevent supports to return that event in the submission syscall without additional overhead by reading it from ring or queue).
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · Evgeniy Polyakov
Yes, it is about 98-100% in both cases.
I've just re-run tests on my amd64 test machine without debug options:epoll 4794.23
kevent 6468.95
It would be valuable if you could post oprofile results (CPU_CLK_UNHALTED) for both tests.
Thank you
Quoted 11 lines · Eric Dumazet
Quoted 6 lines · Evgeniy Polyakov
Yes, it is about 98-100% in both cases.
I've just re-run tests on my amd64 test machine without debug options:epoll 4794.23
kevent 6468.95It would be valuable if you could post oprofile results (
CPU_CLK_UNHALTED) for both tests.
I can't - oprofile does not work on this x86_64 machine:
#opcontrol --setup --vmlinux=/home/s0mbre/aWork/git/linux-2.6.kevent/vmlinux
# opcontrol --start Using default event: CPU_CLK_UNHALTED:100000:0:1:1 /usr/bin/opcontrol: line 994: /dev/oprofile/0/enabled: No such file or directory /usr/bin/opcontrol: line 994: /dev/oprofile/0/event: No such file or directory /usr/bin/opcontrol: line 994: /dev/oprofile/0/count: No such file or directory /usr/bin/opcontrol: line 994: /dev/oprofile/0/kernel: No such file or directory /usr/bin/opcontrol: line 994: /dev/oprofile/0/user: No such file or directory /usr/bin/opcontrol: line 994: /dev/oprofile/0/unit_mask: No such file or directory
# ls -l /dev/oprofile/ total 0 drwxr-xr-x 1 root root 0 2007-03-01 09:41 1 drwxr-xr-x 1 root root 0 2007-03-01 09:41 2 drwxr-xr-x 1 root root 0 2007-03-01 09:41 3 -rw-r--r-- 1 root root 0 2007-03-01 09:41 backtrace_depth -rw-r--r-- 1 root root 0 2007-03-01 09:41 buffer -rw-r--r-- 1 root root 0 2007-03-01 09:41 buffer_size -rw-r--r-- 1 root root 0 2007-03-01 09:41 buffer_watershed -rw-r--r-- 1 root root 0 2007-03-01 09:41 cpu_buffer_size -rw-r--r-- 1 root root 0 2007-03-01 09:41 cpu_type -rw-rw-rw- 1 root root 0 2007-03-01 09:41 dump -rw-r--r-- 1 root root 0 2007-03-01 09:41 enable -rw-r--r-- 1 root root 0 2007-03-01 09:41 pointer_size drwxr-xr-x 1 root root 0 2007-03-01 09:41 stats
Quoted 1 line
Thank you
Signature · 1 line
Evgeniy Polyakov
Quoted 1 line · Evgeniy Polyakov
On Thu, Mar 01, 2007 at 12:14:44PM +0100, Eric Dumazet ([email protected])
Quoted 4 lines · wrote:
Quoted 4 lines · Evgeniy Polyakov
Quoted 3 lines
Yes, it is about 98-100% in both cases.
I've just re-run tests on my amd64 test machine without debug options:
Quoted 8 lines
Quoted 5 lines
Quoted 2 lines
epoll 4794.23
kevent 6468.95It would be valuable if you could post oprofile results (
CPU_CLK_UNHALTED) for both tests.I can't - oprofile does not work on this
x86_64machine:
Yes, this is a known problem, but you can make it works, as I did.
Please :)
I used the CVS version of oprofile plus a patch you can find in the mailing list archives. Dont remember exactly, since I hit this some months ago
Quoted 13 lines · Eric Dumazet
Quoted 1 line · Evgeniy Polyakov
On Thu, Mar 01, 2007 at 12:14:44PM +0100, Eric Dumazet ([email protected])
Quoted 10 lines · wrote:
Quoted 9 lines · Evgeniy Polyakov
Quoted 5 lines
Yes, it is about 98-100% in both cases.
I've just re-run tests on my amd64 test machine without debug options:epoll 4794.23
kevent 6468.95It would be valuable if you could post oprofile results (
CPU_CLK_UNHALTED) for both tests.
Quoted 6 lines
Quoted 2 lines
I can't - oprofile does not work on this
x86_64machine:Yes, this is a known problem, but you can make it works, as I did.
Please :)
I can not resist :)
Quoted 2 lines
I used the CVS version of oprofile plus a patch you can find in the mailing list archives. Dont remember exactly, since I hit this some months ago
Could you provide at least remote way to find it?
I only found the same problem at
http://lkml.org/lkml/2006/10/27/3
but without any hits to solve the problem.
I will try CVS oprofile, if it works I will provide details of course.
My tree is based on rc1 and has this latest commit:
commit b5bf28cde894b3bb3bd25c13a7647020562f9ea0
Author: Linus Torvalds <[email protected]> Date: Wed Feb 21 11:21:44 2007 -0800
There are no commits after that data with word 'oprofile' in git-whatchanged at least.
Signature · 1 line
Evgeniy Polyakov
Quoted 3 lines · Evgeniy Polyakov
Could you provide at least remote way to find it?
Sure :)
Quoted 7 lines
I only found the same problem at
http://lkml.org/lkml/2006/10/27/3but without any hits to solve the problem.
I will try CVS oprofile, if it works I will provide details of course.
# cat CVS/Root CVS/Root::pserver:[email protected]:/cvsroot/oprofile
# cvs diff >/tmp/oprofile.diff
Hope it helps
Index: libop/op_alloc_counter.c
===================================================================
RCS file: /cvsroot/oprofile/oprofile/libop/op_alloc_counter.c,v retrieving revision 1.8
diff -r1.8 op_alloc_counter.c
14a15,16
Quoted 2 lines
#include <
ctype.h>
#include <dirent.h>
133c135
< return 0;
---
Quoted 1 line
continue;
145a148,183
Quoted 28 lines
/* determine which directories are counter directories
*/
static intperfcounterdir(const struct dirent * entry){ return (isdigit(entry->d_name[0])); }/**
* @param mask pointer where to place bit mask of unavailable counters *
* return >= 0 number of counters that are available
* < 0 could not determine number of counters
*
*/
static intop_get_counter_mask(u32 * mask){ struct dirent **counterlist; int count, i; /* assume nothing is available */ u32 available=0; count = scandir("/dev/oprofile", &counterlist, perfcounterdir, alphasort); if (count < 0) /* unable to determine bit mask */ return -1; /* convert to bit map (0 where counter exists) */
Quoted 8 lines
for (i=0; i<count; ++i) {
available |= 1 << atoi(counterlist[i]->d_name);
free(counterlist[i]);
}
*mask=~available;
free(counterlist);
return count;
}152a191
Quoted 1 line
u32 unavailable_counters = 0;
154c193,195
< nr_counters = op_get_nr_counters(cpu_type);
---
Quoted 3 lines
nr_counters = op_get_counter_mask(&unavailable_counters); if (nr_counters < 0) nr_counters = op_get_nr_counters(cpu_type);
162c203,204
< if (!allocate_counter(ctr_arc, nr_events, 0, 0, counter_map)) {
---
Quoted 2 lines
if (!allocate_counter(ctr_arc, nr_events, 0, unavailable_counters,
counter_map)) {Quoted 15 lines · Eric Dumazet
Quoted 3 lines · Evgeniy Polyakov
Could you provide at least remote way to find it?
Sure :)
Quoted 7 lines
I only found the same problem at
http://lkml.org/lkml/2006/10/27/3but without any hits to solve the problem.
I will try CVS oprofile, if it works I will provide details of course.
Quoted 6 lines
# cat CVS/Root CVS/Root::pserver:[email protected]:/cvsroot/oprofile# cvs diff >/tmp/oprofile.diffHope it helps
One of the hunks failed, since it was in CVS already. After setting up some mirrors, I've installed all bits needed for oprofile.
Attached kevent and epoll profiles.
In that tests I got epoll perf about 4400 req/s, kevent was about 5300.
epoll does not contain gettimeofday() call.
Signature · 1 line
Evgeniy Polyakov
CPU: AMD64 processors, speed 2210.08 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Cycles outside of halt state) with a unit mask of 0x00 (No unit mask) count 100000
samples % symbol name 195750 67.3097 cpu_idle 14111 4.8521 enter_idle 4979 1.7121 IRQ0x51_interrupt 4765 1.6385 tcp_v4_rcv 3316 1.1402 tcp_ack 3138 1.0790 kmem_cache_free 2619 0.9006 kfree 2323 0.7988 memset_c 1747 0.6007 schedule 1682 0.5784 csum_partial_copy_generic 1646 0.5660 ip_output 1563 0.5374 tcp_rcv_state_process 1506 0.5178 dev_queue_xmit 1412 0.4855 handle_IRQ_event 1266 0.4353 ip_rcv 1026 0.3528 ip_queue_xmit 1004 0.3452 __do_softirq 1001 0.3442 ip_local_deliver 906 0.3115 csum_partial 902 0.3102 ip_route_input 889 0.3057 __d_lookup 880 0.3026 kmem_cache_alloc 847 0.2912 tcp_v4_do_rcv 841 0.2892 netif_receive_skb 830 0.2854 tcp_sendmsg 819 0.2816 system_call 788 0.2710 kfree_skbmem 780 0.2682 tcp_transmit_skb 742 0.2551 preempt_schedule 731 0.2514 __tcp_push_pending_frames 699 0.2404 __link_path_walk 687 0.2362 pfifo_fast_dequeue 672 0.2311 local_bh_enable 657 0.2259 __alloc_skb 650 0.2235 net_rx_action 627 0.2156 pfifo_fast_enqueue 583 0.2005 sock_wfree 571 0.1963 get_unused_fd 547 0.1881 tcp_parse_options 546 0.1877 copy_user_generic_string 533 0.1833 _atomic_dec_and_lock 529 0.1819 number 524 0.1802 ret_from_intr 509 0.1750 skb_clone 507 0.1743 fget 507 0.1743 tcp_rcv_established 498 0.1712 __kfree_skb 492 0.1692 tcp_poll 481 0.1654 rt_hash_code 471 0.1620 dput 454 0.1561 sock_def_readable 422 0.1451 mask_and_ack_8259A 421 0.1448 sysret_check 419 0.1441 __fput 413 0.1420 exit_idle 396 0.1362 ip_append_data 374 0.1286 sock_poll 371 0.1276 tcp_data_queue 359 0.1234 __tcp_select_window 356 0.1224 tcp_recvmsg 348 0.1197 lock_timer_base 340 0.1169 cache_alloc_refill 338 0.1162 thread_return 319 0.1097 sys_close 318 0.1093 do_path_lookup 318 0.1093 ret_from_sys_call 311 0.1069 vsnprintf 307 0.1056 eth_type_trans 303 0.1042 find_next_zero_bit 302 0.1038 __mod_timer 298 0.1025 d_alloc 296 0.1018 rb_erase 293 0.1007 call_softirq 290 0.0997 __dentry_open 276 0.0949 cache_grow 274 0.0942 __ip_route_output_key 273 0.0939 try_to_wake_up 258 0.0887 dentry_iput 258 0.0887 sk_stream_mem_schedule 257 0.0884 do_lookup 244 0.0839 strncpy_from_user 234 0.0805 do_generic_mapping_read 231 0.0794 memcmp 229 0.0787 tcp_current_mss 228 0.0784 tcp_rtt_estimator 214 0.0736 restore_args 205 0.0705 sys_recvfrom 204 0.0701 fput 203 0.0698 tcp_send_fin 200 0.0688 release_sock 193 0.0664 memcpy_c 191 0.0657 common_interrupt 189 0.0650 fget_light 185 0.0636 skb_checksum 182 0.0626 generic_drop_inode 180 0.0619 do_sys_open 174 0.0598 get_page_from_freelist 168 0.0578 link_path_walk 165 0.0567 schedule_timeout 163 0.0560 del_timer 162 0.0557 rb_insert_color 160 0.0550 percpu_counter_mod 159 0.0547 __up_read 155 0.0533 expand_files 154 0.0530 sys_fcntl 150 0.0516 tcp_v4_send_check 146 0.0502 fd_install 145 0.0499 bictcp_cong_avoid 143 0.0492 call_rcu 141 0.0485 __down_read 141 0.0485 sock_close 140 0.0481 copy_page_c 138 0.0475 __skb_checksum_complete 138 0.0475 lookup_mnt 137 0.0471 getname 132 0.0454 generic_permission 131 0.0450 find_get_page 130 0.0447 __do_page_cache_readahead 130 0.0447 update_send_head 127 0.0437 get_empty_filp 126 0.0433 __path_lookup_intent_open 124 0.0426 mod_timer 122 0.0420 half_md4_transform 121 0.0416 page_fault 121 0.0416 tcp_sync_mss 120 0.0413 __wake_up 120 0.0413 current_fs_time 119 0.0409 remove_wait_queue 118 0.0406 groups_search 116 0.0399 __handle_mm_fault 115 0.0395 tcp_send_ack 114 0.0392 get_task_mm 109 0.0375 tcp_snd_test 107 0.0368 new_inode 106 0.0364 sock_release 106 0.0364 tcp_init_tso_segs 104 0.0358 inotify_dentry_parent_queue_event 104 0.0358 try_to_del_timer_sync 102 0.0351 add_wait_queue 99 0.0340 cond_resched 97 0.0334 __follow_mount 96 0.0330 __put_unused_fd 95 0.0327 open_namei 94 0.0323 file_move 93 0.0320 clear_inode 93 0.0320 permission 92 0.0316 rw_verify_area 91 0.0313 may_open 91 0.0313 memmove 86 0.0296 __up_write 86 0.0296 dnotify_flush 86 0.0296 tcp_select_initial_window 84 0.0289 sock_common_recvmsg 83 0.0285 __wake_up_bit 83 0.0285 page_cache_readahead 82 0.0282 IRQ0x20_interrupt 81 0.0279 put_page 77 0.0265 inet_sendmsg 76 0.0261 skb_copy_datagram_iovec 76 0.0261 tcp_init_cwnd 75 0.0258 sock_recvmsg 75 0.0258 tcp_event_data_recv 74 0.0254 inet_sk_rebuild_header 74 0.0254 locks_remove_posix 73 0.0251 d_instantiate 68 0.0234 sock_sendmsg 66 0.0227 __rb_rotate_right 65 0.0224 __down_write_nested 65 0.0224 retint_kernel 64 0.0220 alloc_inode 64 0.0220 clear_page_c 64 0.0220 init_timer 63 0.0217 mntput_no_expire 63 0.0217 sk_reset_timer 63 0.0217 tcp_setsockopt 61 0.0210 tcp_check_space 61 0.0210 unmap_vmas 60 0.0206 filp_close 60 0.0206 tcp_v4_tw_remember_stamp 59 0.0203 tcp_rcv_space_adjust 56 0.0193 inotify_inode_queue_event 54 0.0186 __delay 54 0.0186 touch_atime 53 0.0182 sk_stream_rfree 53 0.0182 sys_open 53 0.0182 tcp_cwnd_validate 50 0.0172 copy_to_user 50 0.0172 file_kill 49 0.0168 generic_file_open 46 0.0158 tcp_cong_avoid 44 0.0151 do_filp_open 44 0.0151 inet_sock_destruct 43 0.0148 __rb_rotate_left 43 0.0148 __tcp_ack_snd_check 43 0.0148 inode_init_once 43 0.0148 sprintf 42 0.0144 exit_intr 42 0.0144 sock_fasync 42 0.0144 wake_up_inode 41 0.0141 memset 39 0.0134 __alloc_pages 39 0.0134 free_hot_cold_page 39 0.0134 vfs_permission 38 0.0131 bit_waitqueue 38 0.0131 do_page_fault 38 0.0131 locks_remove_flock 38 0.0131 tcp_unhash 36 0.0124 del_timer_sync 36 0.0124 iput 36 0.0124 iret_label 35 0.0120 file_free_rcu 35 0.0120 file_ra_state_init 35 0.0120 tcp_v4_destroy_sock 34 0.0117 sk_stop_timer 33 0.0113 __lookup_mnt 33 0.0113 inet_getname 33 0.0113 zone_watermark_ok 30 0.0103 copy_page_range 29 0.0100 blockable_page_cache_readahead 29 0.0100 do_wp_page 29 0.0100 hrtimer_run_queues 29 0.0100 sk_alloc 26 0.0089 _spin_lock_bh 26 0.0089 in_group_p 25 0.0086 __put_user_8 25 0.0086 __wake_up_locked 25 0.0086 find_vma 25 0.0086 init_once 24 0.0083 __lock_text_start 23 0.0079 destroy_inode 23 0.0079 tcp_slow_start 22 0.0076 mark_page_accessed 21 0.0072 flush_tlb_page 20 0.0069 _read_lock_irqsave 20 0.0069 memcpy_toiovec 18 0.0062 apic_timer_interrupt 18 0.0062 retint_restore_args 18 0.0062 vm_normal_page 14 0.0048 __down_write 14 0.0048 __tcp_checksum_complete_user 14 0.0048 invalidate_inode_buffers 13 0.0045 mutex_lock 11 0.0038 __get_user_4 11 0.0038 error_exit 11 0.0038 wake_up_bit 10 0.0034 __block_write_full_page 10 0.0034 __down_read_trylock 10 0.0034 copy_from_user 9 0.0031 copy_process 9 0.0031 timespec_trunc 7 0.0024 dup_fd 7 0.0024 filemap_nopage 7 0.0024 lru_cache_add_active 7 0.0024 memcpy 7 0.0024 nameidata_to_filp 7 0.0024 unlink_file_vma 6 0.0021 __find_get_block 6 0.0021 __mutex_init 6 0.0021 find_get_pages_tag 6 0.0021 inode_has_buffers 6 0.0021 mmput 6 0.0021 page_remove_rmap 6 0.0021 sys_mprotect 5 0.0017 __mark_inode_dirty 5 0.0017 do_mmap_pgoff 5 0.0017 error_sti 5 0.0017 free_hot_page 5 0.0017 load_elf_binary 5 0.0017 page_waitqueue 5 0.0017 radix_tree_tag_clear 5 0.0017 rcu_start_batch 5 0.0017 retint_swapgs 4 0.0014 _spin_lock_irqsave 4 0.0014 copy_strings 4 0.0014 free_pages 4 0.0014 free_pgd_range 4 0.0014 free_pgtables 4 0.0014 page_add_file_rmap 4 0.0014 run_local_timers 4 0.0014 sys_rt_sigprocmask 4 0.0014 unlock_page 4 0.0014 vma_link 3 0.0010 __getblk 3 0.0010 __pagevec_lru_add_active 3 0.0010 __strnlen_user 3 0.0010 _write_lock_bh 3 0.0010 anon_vma_prepare 3 0.0010 anon_vma_unlink 3 0.0010 bio_alloc_bioset 3 0.0010 dnotify_parent 3 0.0010 do_exit 3 0.0010 do_wait 3 0.0010 exit_mmap 3 0.0010 kthread_should_stop 3 0.0010 prio_tree_insert 3 0.0010 remove_vma 3 0.0010 retint_check 3 0.0010 vma_prio_tree_add 2 6.9e-04 __block_prepare_write 2 6.9e-04 __bread 2 6.9e-04 __end_that_request_first 2 6.9e-04 __find_get_block_slow 2 6.9e-04 __free_pages 2 6.9e-04 __vm_enough_memory 2 6.9e-04 alloc_page_vma 2 6.9e-04 arch_unmap_area 2 6.9e-04 bio_init 2 6.9e-04 blk_recount_segments 2 6.9e-04 block_write_full_page 2 6.9e-04 clear_page_dirty_for_io 2 6.9e-04 do_group_exit 2 6.9e-04 do_munmap 2 6.9e-04 do_notify_resume 2 6.9e-04 find_vma_prepare 2 6.9e-04 find_vma_prev 2 6.9e-04 generic_fillattr 2 6.9e-04 get_index 2 6.9e-04 get_unmapped_area 2 6.9e-04 get_vma_policy 2 6.9e-04 prio_tree_remove 2 6.9e-04 prio_tree_replace 2 6.9e-04 proc_get_inode 2 6.9e-04 proc_lookup 2 6.9e-04 release_pages 2 6.9e-04 show_vfsmnt 2 6.9e-04 strchr 2 6.9e-04 sys_dup2 2 6.9e-04 sys_faccessat 2 6.9e-04 sys_mmap 2 6.9e-04 test_set_page_writeback 2 6.9e-04 unmap_region 2 6.9e-04 vm_acct_memory 2 6.9e-04 vm_stat_account 2 6.9e-04 vma_adjust 2 6.9e-04 vma_merge 2 6.9e-04 vma_prio_tree_remove 2 6.9e-04 zonelist_policy 1 3.4e-04 __brelse 1 3.4e-04 __clear_user 1 3.4e-04 __d_path 1 3.4e-04 __lookup_hash 1 3.4e-04 __make_request 1 3.4e-04 __page_set_anon_rmap 1 3.4e-04 __pagevec_lru_add 1 3.4e-04 __pmd_alloc 1 3.4e-04 __pollwait 1 3.4e-04 __pte_alloc 1 3.4e-04 __pud_alloc 1 3.4e-04 __put_user_4 1 3.4e-04 add_to_page_cache 1 3.4e-04 alloc_pages_current 1 3.4e-04 blk_rq_map_sg 1 3.4e-04 can_share_swap_page 1 3.4e-04 can_vma_merge_after 1 3.4e-04 copy_semundo 1 3.4e-04 cp_new_stat 1 3.4e-04 cpuset_update_task_memory_state 1 3.4e-04 d_delete 1 3.4e-04 d_path 1 3.4e-04 dcache_readdir 1 3.4e-04 default_llseek 1 3.4e-04 do_arch_prctl 1 3.4e-04 do_brk 1 3.4e-04 do_fsync 1 3.4e-04 do_mpage_readpage 1 3.4e-04 do_sigaction 1 3.4e-04 do_sigaltstack 1 3.4e-04 dupfd 1 3.4e-04 elf_map 1 3.4e-04 end_page_writeback 1 3.4e-04 error_entry 1 3.4e-04 exit_sem 1 3.4e-04 fasync_helper 1 3.4e-04 file_permission 1 3.4e-04 file_read_actor 1 3.4e-04 flush_signal_handlers 1 3.4e-04 flush_thread 1 3.4e-04 generic_delete_inode 1 3.4e-04 generic_file_aio_write 1 3.4e-04 generic_file_buffered_write 1 3.4e-04 generic_file_mmap 1 3.4e-04 get_request_wait 1 3.4e-04 get_signal_to_deliver 1 3.4e-04 get_stack 1 3.4e-04 hrtimer_init 1 3.4e-04 kill_fasync 1 3.4e-04 kmem_flagcheck 1 3.4e-04 meminfo_read_proc 1 3.4e-04 mempool_free 1 3.4e-04 memscan 1 3.4e-04 mutex_unlock 1 3.4e-04 notify_change 1 3.4e-04 nr_blockdev_pages 1 3.4e-04 page_add_new_anon_rmap 1 3.4e-04 path_release 1 3.4e-04 pipe_ioctl 1 3.4e-04 pipe_iov_copy_from_user 1 3.4e-04 poll_freewait 1 3.4e-04 proc_file_read 1 3.4e-04 proc_pident_lookup 1 3.4e-04 ptregscall_common 1 3.4e-04 rb_next 1 3.4e-04 recalc_bh_state 1 3.4e-04 release_task 1 3.4e-04 retint_careful 1 3.4e-04 schedule_tail 1 3.4e-04 seq_escape 1 3.4e-04 set_brk 1 3.4e-04 set_normalized_timespec 1 3.4e-04 si_swapinfo 1 3.4e-04 split_vma 1 3.4e-04 stub_execve 1 3.4e-04 sync_sb_inodes 1 3.4e-04 sys_brk 1 3.4e-04 sys_lseek 1 3.4e-04 sys_munmap 1 3.4e-04 sys_newfstat 1 3.4e-04 sys_newstat 1 3.4e-04 sys_select 1 3.4e-04 sys_write 1 3.4e-04 truncate_complete_page 1 3.4e-04 tty_ioctl 1 3.4e-04 udp_rcv 1 3.4e-04 unlock_buffer 1 3.4e-04 vfs_readdir 1 3.4e-04 vma_prio_tree_insert 1 3.4e-04 worker_thread CPU: AMD64 processors, speed 2210.08 MHz (estimated) Counted CPU_CLK_UNHALTED events (Cycles outside of halt state) with a unit mask of 0x00 (No unit mask) count 100000 samples % symbol name 124605 59.0887 cpu_idle 13754 6.5223 enter_idle 4677 2.2179 tcp_v4_rcv 3888 1.8437 IRQ0x51_interrupt 3115 1.4772 tcp_ack 2571 1.2192 kmem_cache_free 2151 1.0200 kfree 2121 1.0058 memset_c 1632 0.7739 csum_partial_copy_generic 1611 0.7639 ip_output 1488 0.7056 schedule 1389 0.6587 dev_queue_xmit 1352 0.6411 tcp_rcv_state_process 1272 0.6032 ip_rcv 1184 0.5615 handle_IRQ_event 951 0.4510 ip_queue_xmit 916 0.4344 __do_softirq 900 0.4268 ip_route_input 888 0.4211 csum_partial 870 0.4126 tcp_v4_do_rcv 856 0.4059 ip_local_deliver 851 0.4036 system_call 829 0.3931 netif_receive_skb 812 0.3851 tcp_sendmsg 812 0.3851 tcp_transmit_skb 805 0.3817 __alloc_skb 683 0.3239 kmem_cache_alloc 683 0.3239 local_bh_enable 678 0.3215 __tcp_push_pending_frames 673 0.3191 fget 665 0.3153 __d_lookup 653 0.3097 pfifo_fast_enqueue 639 0.3030 copy_user_generic_string 607 0.2878 preempt_schedule 606 0.2874 net_rx_action 593 0.2812 pfifo_fast_dequeue 589 0.2793 kfree_skbmem 552 0.2618 __fput 550 0.2608 __link_path_walk 528 0.2504 skb_clone 523 0.2480 tcp_parse_options 515 0.2442 ret_from_intr 512 0.2428 number 496 0.2352 _atomic_dec_and_lock 493 0.2338 __kfree_skb 477 0.2262 rt_hash_code 476 0.2257 sock_wfree 459 0.2177 tcp_poll 449 0.2129 tcp_rcv_established 415 0.1968 dput 398 0.1887 sysret_check 366 0.1736 exit_idle 364 0.1726 __mod_timer 352 0.1669 tcp_recvmsg 352 0.1669 thread_return 346 0.1641 sys_close 341 0.1617 get_unused_fd 340 0.1612 rb_erase 337 0.1598 __tcp_select_window 331 0.1570 lock_timer_base 316 0.1498 mask_and_ack_8259A 299 0.1418 ip_append_data 290 0.1375 cache_alloc_refill 286 0.1356 d_alloc 269 0.1276 ret_from_sys_call 268 0.1271 do_path_lookup 267 0.1266 call_softirq 265 0.1257 eth_type_trans 262 0.1242 tcp_current_mss 262 0.1242 tcp_data_queue 262 0.1242 vsnprintf 261 0.1238 __ip_route_output_key 255 0.1209 sk_stream_mem_schedule 249 0.1181 cache_grow 247 0.1171 tcp_rtt_estimator 239 0.1133 __dentry_open 221 0.1048 sys_fcntl 220 0.1043 find_next_zero_bit 216 0.1024 dentry_iput 208 0.0986 try_to_wake_up 197 0.0934 call_rcu 196 0.0929 strncpy_from_user 195 0.0925 do_lookup 191 0.0906 sock_recvmsg 189 0.0896 tcp_send_fin 188 0.0892 sys_recvfrom 182 0.0863 sock_def_readable 178 0.0844 restore_args 176 0.0835 common_interrupt 174 0.0825 release_sock 171 0.0811 do_generic_mapping_read 167 0.0792 schedule_timeout 163 0.0773 generic_drop_inode 163 0.0773 get_page_from_freelist 163 0.0773 percpu_counter_mod 160 0.0759 skb_checksum 159 0.0754 del_timer 155 0.0735 do_sys_open 153 0.0726 memcpy_c 149 0.0707 memcmp 145 0.0688 __skb_checksum_complete 144 0.0683 link_path_walk 144 0.0683 tcp_v4_send_check 141 0.0669 fd_install 140 0.0664 get_empty_filp 139 0.0659 fget_light 131 0.0621 current_fs_time 126 0.0598 mod_timer 125 0.0593 bictcp_cong_avoid 123 0.0583 tcp_init_tso_segs 121 0.0574 update_send_head 120 0.0569 __put_unused_fd 119 0.0564 __do_page_cache_readahead 119 0.0564 alloc_inode 118 0.0560 rb_insert_color 115 0.0545 prepare_to_wait 112 0.0531 locks_remove_posix 112 0.0531 new_inode 111 0.0526 half_md4_transform 109 0.0517 fput 108 0.0512 tcp_sync_mss 105 0.0498 get_task_mm 104 0.0493 clear_inode 102 0.0484 find_get_page 102 0.0484 tcp_select_initial_window 101 0.0479 lookup_mnt 101 0.0479 tcp_send_ack 99 0.0469 sock_close 98 0.0465 try_to_del_timer_sync 97 0.0460 page_cache_readahead 97 0.0460 tcp_snd_test 94 0.0446 generic_permission 94 0.0446 getname 92 0.0436 may_open 91 0.0432 tcp_event_data_recv 90 0.0427 open_namei 89 0.0422 IRQ0x20_interrupt 88 0.0417 inotify_dentry_parent_queue_event 87 0.0413 put_page 85 0.0403 copy_page_c 84 0.0398 d_instantiate 81 0.0384 finish_wait 80 0.0379 __wake_up 79 0.0375 expand_files 77 0.0365 groups_search 75 0.0356 inet_sendmsg 75 0.0356 skb_copy_datagram_iovec 73 0.0346 file_free_rcu 72 0.0341 __path_lookup_intent_open 72 0.0341 permission 71 0.0337 __follow_mount 71 0.0337 memmove 70 0.0332 dnotify_flush 69 0.0327 cond_resched 69 0.0327 igrab 68 0.0322 sk_reset_timer 66 0.0313 sockfd_lookup 65 0.0308 tcp_setsockopt 64 0.0303 sock_sendmsg 62 0.0294 __wake_up_bit 62 0.0294 file_move 62 0.0294 inotify_inode_queue_event 62 0.0294 retint_kernel 62 0.0294 tcp_v4_tw_remember_stamp 60 0.0285 sprintf 56 0.0266 copy_to_user 56 0.0266 sock_common_recvmsg 56 0.0266 tcp_check_space 56 0.0266 tcp_cwnd_validate 55 0.0261 file_kill 55 0.0261 inet_sk_rebuild_header 55 0.0261 tcp_init_cwnd 54 0.0256 __handle_mm_fault 54 0.0256 init_timer 52 0.0247 filp_close 52 0.0247 mutex_unlock 52 0.0247 rw_verify_area 51 0.0242 sock_release 48 0.0228 __tcp_ack_snd_check 48 0.0228 sys_open 47 0.0223 inode_init_once 47 0.0223 locks_remove_flock 47 0.0223 mntput_no_expire 47 0.0223 touch_atime 46 0.0218 sk_stream_rfree 45 0.0213 page_fault 45 0.0213 unmap_vmas 45 0.0213 wake_up_inode 44 0.0209 clear_page_c 44 0.0209 memset 42 0.0199 __delay 42 0.0199 tcp_cong_avoid 41 0.0194 __rb_rotate_left 39 0.0185 do_filp_open 39 0.0185 memcpy_toiovec 39 0.0185 sock_fasync 38 0.0180 __put_user_8 38 0.0180 exit_intr 35 0.0166 zone_watermark_ok 34 0.0161 iput 33 0.0156 iret_label 32 0.0152 free_hot_cold_page 32 0.0152 tcp_unhash 31 0.0147 __alloc_pages 31 0.0147 sk_alloc 30 0.0142 __lookup_mnt 30 0.0142 mutex_lock 29 0.0138 generic_file_open 28 0.0133 _spin_lock_bh 28 0.0133 bit_waitqueue 28 0.0133 tcp_rcv_space_adjust 27 0.0128 inet_sock_destruct 26 0.0123 sk_stop_timer 26 0.0123 tcp_slow_start 24 0.0114 hrtimer_run_queues 24 0.0114 inet_getname 22 0.0104 file_ra_state_init 22 0.0104 vfs_permission 21 0.0100 blockable_page_cache_readahead 21 0.0100 tcp_v4_destroy_sock 20 0.0095 init_once 19 0.0090 do_wp_page 18 0.0085 destroy_inode 16 0.0076 apic_timer_interrupt 16 0.0076 copy_from_user 16 0.0076 del_timer_sync 15 0.0071 in_group_p 15 0.0071 invalidate_inode_buffers 14 0.0066 do_page_fault 13 0.0062 mark_page_accessed 13 0.0062 retint_restore_args 12 0.0057 __get_user_4 11 0.0052 copy_page_range 11 0.0052 find_vma 11 0.0052 wake_up_bit 10 0.0047 __down_read 9 0.0043 rcu_start_batch 8 0.0038 __tcp_checksum_complete_user 8 0.0038 __up_read 8 0.0038 flush_tlb_page 8 0.0038 free_pages 8 0.0038 timespec_trunc 6 0.0028 __find_get_block 6 0.0028 __rb_rotate_right 6 0.0028 error_sti 6 0.0028 kmem_flagcheck 6 0.0028 retint_swapgs 5 0.0024 __down_read_trylock 5 0.0024 _spin_lock_irqsave 5 0.0024 inode_has_buffers 5 0.0024 retint_check 4 0.0019 __mutex_init 4 0.0019 nameidata_to_filp 4 0.0019 prio_tree_insert 4 0.0019 proc_lookup 4 0.0019 run_workqueue 3 0.0014 __getblk 3 0.0014 __iget 3 0.0014 __pagevec_lru_add_active 3 0.0014 __strnlen_user 3 0.0014 _write_lock_bh 3 0.0014 copy_process 3 0.0014 error_exit 3 0.0014 filemap_nopage 3 0.0014 mmput 3 0.0014 sys_mprotect 3 0.0014 unlink_file_vma 3 0.0014 vma_adjust 2 9.5e-04 __clear_user 2 9.5e-04 __end_that_request_first 2 9.5e-04 __pte_alloc 2 9.5e-04 __set_page_dirty_nobuffers 2 9.5e-04 _read_lock_bh 2 9.5e-04 _read_lock_irqsave 2 9.5e-04 add_to_page_cache 2 9.5e-04 anon_vma_prepare 2 9.5e-04 anon_vma_unlink 2 9.5e-04 d_lookup 2 9.5e-04 do_exit 2 9.5e-04 do_mmap_pgoff 2 9.5e-04 do_munmap 2 9.5e-04 do_wait 2 9.5e-04 dup_fd 2 9.5e-04 flush_signal_handlers 2 9.5e-04 free_hot_page 2 9.5e-04 generic_file_aio_read 2 9.5e-04 generic_fillattr 2 9.5e-04 generic_make_request 2 9.5e-04 kthread_should_stop 2 9.5e-04 load_elf_binary 2 9.5e-04 lru_add_drain 2 9.5e-04 lru_cache_add_active 2 9.5e-04 memcpy 2 9.5e-04 mempool_free 2 9.5e-04 mm_init 2 9.5e-04 page_remove_rmap 2 9.5e-04 put_unused_fd 2 9.5e-04 radix_tree_tag_clear 2 9.5e-04 rb_next 2 9.5e-04 retint_with_reschedule 2 9.5e-04 run_local_timers 2 9.5e-04 strchr 2 9.5e-04 vfs_ioctl 2 9.5e-04 vma_link 1 4.7e-04 __add_entropy_words 1 4.7e-04 __anon_vma_link 1 4.7e-04 __brelse 1 4.7e-04 __d_path 1 4.7e-04 __down_write 1 4.7e-04 __find_get_block_slow 1 4.7e-04 __free_pages 1 4.7e-04 __generic_file_aio_write_nolock 1 4.7e-04 __lookup_hash 1 4.7e-04 __make_request 1 4.7e-04 __mark_inode_dirty 1 4.7e-04 __page_set_anon_rmap 1 4.7e-04 __pagevec_lru_add 1 4.7e-04 __pagevec_release 1 4.7e-04 __remove_shared_vm_struct 1 4.7e-04 __up_write 1 4.7e-04 __user_walk_fd 1 4.7e-04 __vm_enough_memory 1 4.7e-04 __writeback_single_inode 1 4.7e-04 alloc_buffer_head 1 4.7e-04 alloc_page_buffers 1 4.7e-04 alloc_pages_current 1 4.7e-04 bio_alloc_bioset 1 4.7e-04 blk_done_softirq 1 4.7e-04 blk_recount_segments 1 4.7e-04 blk_rq_map_sg 1 4.7e-04 can_vma_merge_before 1 4.7e-04 cfq_set_request 1 4.7e-04 copy_strings 1 4.7e-04 cpuset_update_task_memory_state 1 4.7e-04 create_empty_buffers 1 4.7e-04 deny_write_access 1 4.7e-04 do_arch_prctl 1 4.7e-04 do_mpage_readpage 1 4.7e-04 do_select 1 4.7e-04 do_sigaction 1 4.7e-04 exit_mm 1 4.7e-04 exit_mmap 1 4.7e-04 find_vma_prepare 1 4.7e-04 find_vma_prev 1 4.7e-04 free_pgtables 1 4.7e-04 get_locked_pte 1 4.7e-04 get_request_wait 1 4.7e-04 get_signal_to_deliver 1 4.7e-04 get_unmapped_area 1 4.7e-04 init_once 1 4.7e-04 init_request_from_bio 1 4.7e-04 inode_setattr 1 4.7e-04 ll_rw_block 1 4.7e-04 make_ahead_window 1 4.7e-04 mapping_tagged 1 4.7e-04 mempool_alloc 1 4.7e-04 n_tty_write_wakeup 1 4.7e-04 notify_change 1 4.7e-04 page_add_file_rmap 1 4.7e-04 pipe_iov_copy_from_user 1 4.7e-04 pipe_write 1 4.7e-04 preempt_schedule_irq 1 4.7e-04 proc_file_read 1 4.7e-04 remove_vma 1 4.7e-04 sched_balance_self 1 4.7e-04 sched_fork 1 4.7e-04 search_binary_handler 1 4.7e-04 sigprocmask 1 4.7e-04 stub_execve 1 4.7e-04 sync_dirty_buffer 1 4.7e-04 sys_execve 1 4.7e-04 sys_ftruncate 1 4.7e-04 tty_ldisc_ref_wait 1 4.7e-04 vfs_write 1 4.7e-04 writeback_inodes
Quoted 7 lines · Evgeniy Polyakov
CPU: AMD64 processors, speed 2210.08 MHz (estimated)
CountedCPU_CLK_UNHALTEDevents (Cycles outside of halt state) with a unit mask of0x00(No unit mask) count 100000samples % symbol name 195750 67.3097 cpu_idle 14111 4.8521 enter_idle 4979 1.7121 IRQ0x51_interrupt 4765 1.6385 tcp_v4_rcv
the pretty much only meaningful way to measure this is to:
- start a really long 'ab' testrun. Something like "ab -c 8000 -t 600".
- let the system get into 'steady state': i.e. CPU load at 100%
- reset the oprofile counters, then start an oprofile run for 60 seconds.
- stop the oprofile run.
- stop the test.
this way there wont be that many 'cpu_idle' entries in your profiles, and the profiles between the two event delivery mechanisms will be directly comparable.
Quoted 2 lines
In that tests I got epoll perf about 4400 req/s, kevent was about 5300.
So we are now up to epoll being 83% of kevent's performance - while the noise of numbers seen today alone is around 100% ... Could you update the files two URLs that you posted before, with the code that you used for the above numbers:
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_epoll.c
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_kevent.c
thanks,
Ingo
Quoted 20 lines · Ingo Molnar
Quoted 7 lines · Evgeniy Polyakov
CPU: AMD64 processors, speed 2210.08 MHz (estimated)
CountedCPU_CLK_UNHALTEDevents (Cycles outside of halt state) with a unit mask of0x00(No unit mask) count 100000samples % symbol name 195750 67.3097 cpu_idle 14111 4.8521 enter_idle 4979 1.7121 IRQ0x51_interrupt 4765 1.6385 tcp_v4_rcvthe pretty much only meaningful way to measure this is to:
- start a really long 'ab' testrun. Something like "ab -c 8000 -t 600".
- let the system get into 'steady state': i.e. CPU load at 100%
- reset the oprofile counters, then start an oprofile run for 60 seconds.
- stop the oprofile run.
- stop the test.
Quoted 3 lines
this way there wont be that many '
cpu_idle' entries in your profiles, and the profiles between the two event delivery mechanisms will be directly comparable.
They are there, since ab runs only 50k requests.
If I change it to something noticebly more than 50/80k, ab crashes:
# ab -c8000 -t 600 -n800000000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.0.48 (be patient)
Segmentation fault
Are there any other tool suitable for such loads?
I only tested httperf (which is worse, since it uses poll/select) and 'ab'.
Btw, host machine runs 100% too, so it is possible that client side is broken (too).
Quoted 7 lines
Quoted 2 lines
In that tests I got epoll perf about 4400 req/s, kevent was about 5300.
So we are now up to epoll being 83% of kevent's performance - while the noise of numbers seen today alone is around 100% ... Could you update the files two URLs that you posted before, with the code that you used for the above numbers:
And in a couple of moments I resent profile with 6100 r/s, and now attached with 6300.
Quoted 2 lines
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_epoll.c
http://tservice.net.ru/~s0mbre/archive/kevent/evserver_kevent.c
Plus http://tservice.net.ru/~s0mbre/archive/kevent/evserver_common.c
which contains common request handling function
Quoted 3 lines
thanks,
Ingo
Signature · 1 line
Evgeniy Polyakov
CPU: AMD64 processors, speed 2210.08 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Cycles outside of halt state) with a unit mask of 0x00 (No unit mask) count 100000
samples % symbol name 168753 65.1189 cpu_idle 12451 4.8046 enter_idle 4814 1.8576 tcp_v4_rcv 3980 1.5358 IRQ0x51_interrupt 3142 1.2124 tcp_ack 2738 1.0565 kmem_cache_free 2346 0.9053 kfree 2341 0.9034 memset_c 1927 0.7436 csum_partial_copy_generic 1723 0.6649 ip_route_input 1650 0.6367 dev_queue_xmit 1452 0.5603 ip_output 1416 0.5464 handle_IRQ_event 1335 0.5152 ip_rcv 1326 0.5117 tcp_rcv_state_process 1069 0.4125 schedule 960 0.3704 __do_softirq 943 0.3639 tcp_sendmsg 915 0.3531 ip_queue_xmit 907 0.3500 tcp_v4_do_rcv 897 0.3461 fget 894 0.3450 system_call 890 0.3434 csum_partial 877 0.3384 tcp_transmit_skb 845 0.3261 netif_receive_skb 822 0.3172 ip_local_deliver 812 0.3133 kmem_cache_alloc 788 0.3041 local_bh_enable 773 0.2983 __alloc_skb 771 0.2975 kfree_skbmem 764 0.2948 __d_lookup 757 0.2921 __tcp_push_pending_frames 734 0.2832 pfifo_fast_enqueue 720 0.2778 copy_user_generic_string 627 0.2419 net_rx_action 603 0.2327 pfifo_fast_dequeue 586 0.2261 ret_from_intr 562 0.2169 __link_path_walk 561 0.2165 sock_wfree 549 0.2118 __fput 547 0.2111 __kfree_skb 543 0.2095 get_unused_fd 534 0.2061 number 527 0.2034 sysret_check 516 0.1991 preempt_schedule 508 0.1960 skb_clone 496 0.1914 tcp_parse_options 487 0.1879 _atomic_dec_and_lock 470 0.1814 tcp_poll 469 0.1810 __ip_route_output_key 466 0.1798 rt_hash_code 464 0.1790 tcp_recvmsg 421 0.1625 dput 420 0.1621 tcp_rcv_established 412 0.1590 __tcp_select_window 407 0.1571 exit_idle 394 0.1520 rb_erase 381 0.1470 sys_close 375 0.1447 __mod_timer 365 0.1408 d_alloc 363 0.1401 mask_and_ack_8259A 335 0.1293 lock_timer_base 315 0.1216 cache_alloc_refill 307 0.1185 ret_from_sys_call 300 0.1158 do_path_lookup 299 0.1154 eth_type_trans 298 0.1150 find_next_zero_bit 294 0.1134 tcp_data_queue 286 0.1104 dentry_iput 285 0.1100 ip_append_data 263 0.1015 thread_return 257 0.0992 __dentry_open 255 0.0984 sock_recvmsg 255 0.0984 tcp_rtt_estimator 252 0.0972 sys_fcntl 250 0.0965 tcp_current_mss 248 0.0957 sk_stream_mem_schedule 240 0.0926 call_softirq 233 0.0899 sys_recvfrom 229 0.0884 cache_grow 221 0.0853 vsnprintf 215 0.0830 tcp_send_fin 214 0.0826 do_generic_mapping_read 213 0.0822 call_rcu 213 0.0822 common_interrupt 203 0.0783 do_lookup 196 0.0756 inotify_dentry_parent_queue_event 191 0.0737 memcpy_c 188 0.0725 filp_close 180 0.0695 release_sock 180 0.0695 sock_def_readable 178 0.0687 get_page_from_freelist 177 0.0683 do_sys_open 174 0.0671 restore_args 172 0.0664 strncpy_from_user 167 0.0644 fget_light 162 0.0625 clear_inode 161 0.0621 link_path_walk 159 0.0614 generic_drop_inode 157 0.0606 get_empty_filp 156 0.0602 __skb_checksum_complete 153 0.0590 del_timer 152 0.0587 update_send_head 151 0.0583 percpu_counter_mod 150 0.0579 current_fs_time 150 0.0579 schedule_timeout 150 0.0579 skb_checksum 149 0.0575 fd_install 145 0.0560 sock_close 143 0.0552 try_to_wake_up 142 0.0548 generic_permission 135 0.0521 __put_unused_fd 133 0.0513 new_inode 132 0.0509 half_md4_transform 131 0.0506 alloc_inode 130 0.0502 bictcp_cong_avoid 130 0.0502 memcmp 127 0.0490 tcp_init_tso_segs 126 0.0486 tcp_sync_mss 125 0.0482 __do_page_cache_readahead 125 0.0482 find_get_page 123 0.0475 lookup_mnt 117 0.0451 rb_insert_color 114 0.0440 tcp_v4_send_check 112 0.0432 mod_timer 109 0.0421 page_cache_readahead 101 0.0390 __path_lookup_intent_open 100 0.0386 __wake_up_bit 100 0.0386 may_open 100 0.0386 tcp_snd_test 97 0.0374 tcp_check_space 96 0.0370 expand_files 96 0.0370 skb_copy_datagram_iovec 95 0.0367 getname 95 0.0367 igrab 94 0.0363 open_namei 93 0.0359 groups_search 92 0.0355 dnotify_flush 91 0.0351 locks_remove_posix 91 0.0351 memmove 90 0.0347 sk_reset_timer 89 0.0343 tcp_send_ack 88 0.0340 copy_page_c 88 0.0340 tcp_select_initial_window 87 0.0336 sock_common_recvmsg 85 0.0328 sock_release 83 0.0320 IRQ0x20_interrupt 83 0.0320 file_free_rcu 80 0.0309 rw_verify_area 79 0.0305 d_instantiate 79 0.0305 permission 79 0.0305 put_page 77 0.0297 cond_resched 77 0.0297 get_task_mm 77 0.0297 touch_atime 75 0.0289 __follow_mount 75 0.0289 inotify_inode_queue_event 74 0.0286 file_move 73 0.0282 copy_to_user 71 0.0274 tcp_v4_tw_remember_stamp 69 0.0266 wake_up_inode 65 0.0251 prepare_to_wait 65 0.0251 sockfd_lookup 65 0.0251 tcp_event_data_recv 64 0.0247 file_kill 64 0.0247 fput 62 0.0239 __handle_mm_fault 62 0.0239 tcp_setsockopt 61 0.0235 sock_sendmsg 60 0.0232 __wake_up 59 0.0228 page_fault 57 0.0220 locks_remove_flock 54 0.0208 sk_stream_rfree 54 0.0208 sprintf 53 0.0205 inet_sendmsg 53 0.0205 retint_kernel 51 0.0197 iret_label 51 0.0197 tcp_cwnd_validate 49 0.0189 tcp_rcv_space_adjust 48 0.0185 inode_init_once 48 0.0185 mutex_unlock 45 0.0174 finish_wait 45 0.0174 mntput_no_expire 44 0.0170 __delay 44 0.0170 __tcp_ack_snd_check 43 0.0166 inet_sock_destruct 42 0.0162 try_to_del_timer_sync 41 0.0158 free_hot_cold_page 41 0.0158 memset 40 0.0154 __rb_rotate_left 40 0.0154 init_once 40 0.0154 sys_open 40 0.0154 tcp_unhash 39 0.0150 generic_file_open 39 0.0150 tcp_cong_avoid 38 0.0147 __lookup_mnt 38 0.0147 bit_waitqueue 36 0.0139 clear_page_c 36 0.0139 iput 33 0.0127 in_group_p 33 0.0127 inet_sk_rebuild_header 33 0.0127 sock_fasync 33 0.0127 tcp_init_cwnd 32 0.0123 memcpy_toiovec 32 0.0123 sk_stop_timer 32 0.0123 unmap_vmas 31 0.0120 blockable_page_cache_readahead 30 0.0116 _spin_lock_bh 30 0.0116 inet_getname 29 0.0112 __put_user_8 28 0.0108 copy_from_user 27 0.0104 do_filp_open 26 0.0100 tcp_v4_destroy_sock 25 0.0096 __alloc_pages 24 0.0093 apic_timer_interrupt 24 0.0093 do_page_fault 24 0.0093 file_ra_state_init 24 0.0093 hrtimer_run_queues 24 0.0093 vfs_permission 23 0.0089 tcp_slow_start 23 0.0089 zone_watermark_ok 22 0.0085 mutex_lock 21 0.0081 destroy_inode 21 0.0081 init_timer 21 0.0081 invalidate_inode_buffers 21 0.0081 sk_alloc 19 0.0073 exit_intr 16 0.0062 copy_page_range 15 0.0058 find_vma 14 0.0054 retint_swapgs 14 0.0054 wake_up_bit 13 0.0050 __down_read 12 0.0046 do_wp_page 12 0.0046 mark_page_accessed 11 0.0042 __get_user_4 11 0.0042 __tcp_checksum_complete_user 10 0.0039 vm_normal_page 9 0.0035 __up_read 8 0.0031 rcu_start_batch 8 0.0031 retint_restore_args 8 0.0031 timespec_trunc 7 0.0027 __find_get_block 7 0.0027 error_exit 7 0.0027 flush_tlb_page 6 0.0023 _write_lock_bh 6 0.0023 copy_process 6 0.0023 free_hot_page 6 0.0023 inode_has_buffers 6 0.0023 kmem_flagcheck 6 0.0023 retint_check 5 0.0019 __rb_rotate_right 5 0.0019 del_timer_sync 5 0.0019 nameidata_to_filp 4 0.0015 __down_read_trylock 4 0.0015 __getblk 4 0.0015 __mutex_init 4 0.0015 __set_page_dirty_nobuffers 4 0.0015 _read_lock_irqsave 4 0.0015 do_mmap_pgoff 4 0.0015 error_sti 4 0.0015 free_pgd_range 4 0.0015 load_elf_binary 4 0.0015 mmput 3 0.0012 __iget 3 0.0012 _spin_lock_irqsave 3 0.0012 bio_endio 3 0.0012 copy_strings 3 0.0012 cpuset_update_task_memory_state 3 0.0012 d_lookup 3 0.0012 exit_itimers 3 0.0012 filemap_nopage 3 0.0012 find_vma_prepare 3 0.0012 free_pages 3 0.0012 generic_fillattr 3 0.0012 generic_make_request 3 0.0012 memcpy 3 0.0012 prio_tree_insert 3 0.0012 put_unused_fd 3 0.0012 run_local_timers 3 0.0012 unmap_region 3 0.0012 vma_prio_tree_remove 2 7.7e-04 __clear_user 2 7.7e-04 __find_get_block_slow 2 7.7e-04 __strnlen_user 2 7.7e-04 __vm_enough_memory 2 7.7e-04 add_to_page_cache 2 7.7e-04 add_wait_queue 2 7.7e-04 alloc_pages_current 2 7.7e-04 anon_vma_prepare 2 7.7e-04 dnotify_parent 2 7.7e-04 do_exit 2 7.7e-04 do_munmap 2 7.7e-04 do_select 2 7.7e-04 dup_fd 2 7.7e-04 exit_mmap 2 7.7e-04 find_mergeable_anon_vma 2 7.7e-04 free_pgtables 2 7.7e-04 lru_cache_add_active 2 7.7e-04 mempool_free 2 7.7e-04 page_add_file_rmap 2 7.7e-04 page_remove_rmap 2 7.7e-04 page_waitqueue 2 7.7e-04 path_release 2 7.7e-04 prio_tree_replace 2 7.7e-04 pty_chars_in_buffer 2 7.7e-04 remove_vma 2 7.7e-04 retint_with_reschedule 2 7.7e-04 run_workqueue 2 7.7e-04 seq_puts 2 7.7e-04 split_vma 2 7.7e-04 sys_mmap 2 7.7e-04 sys_mprotect 2 7.7e-04 sys_rt_sigprocmask 2 7.7e-04 truncate_inode_pages_range 2 7.7e-04 vfs_lstat_fd 2 7.7e-04 vm_acct_memory 2 7.7e-04 vma_adjust 2 7.7e-04 vma_link 1 3.9e-04 __block_prepare_write 1 3.9e-04 __bread 1 3.9e-04 __d_path 1 3.9e-04 __down_write 1 3.9e-04 __down_write_nested 1 3.9e-04 __end_that_request_first 1 3.9e-04 __free_pages 1 3.9e-04 __generic_file_aio_write_nolock 1 3.9e-04 __make_request 1 3.9e-04 __page_set_anon_rmap 1 3.9e-04 __pagevec_lru_add_active 1 3.9e-04 __put_user_4 1 3.9e-04 __remove_shared_vm_struct 1 3.9e-04 __up_write 1 3.9e-04 __vma_link_rb 1 3.9e-04 _read_lock_bh 1 3.9e-04 activate_page 1 3.9e-04 anon_vma_unlink 1 3.9e-04 block_write_full_page 1 3.9e-04 cap_bprm_apply_creds 1 3.9e-04 cap_vm_enough_memory 1 3.9e-04 clear_page_dirty_for_io 1 3.9e-04 cond_resched_lock 1 3.9e-04 cp_new_stat 1 3.9e-04 create_empty_buffers 1 3.9e-04 dentry_unhash 1 3.9e-04 do_brk 1 3.9e-04 do_mpage_readpage 1 3.9e-04 do_mremap 1 3.9e-04 do_sigaction 1 3.9e-04 do_wait 1 3.9e-04 drop_buffers 1 3.9e-04 eligible_child 1 3.9e-04 exit_sem 1 3.9e-04 file_read_actor 1 3.9e-04 filldir64 1 3.9e-04 flush_signal_handlers 1 3.9e-04 generic_block_bmap 1 3.9e-04 generic_file_llseek 1 3.9e-04 generic_file_mmap 1 3.9e-04 get_index 1 3.9e-04 get_signal_to_deliver 1 3.9e-04 get_stack 1 3.9e-04 get_unmapped_area 1 3.9e-04 get_vma_policy 1 3.9e-04 init_request_from_bio 1 3.9e-04 inode_setattr 1 3.9e-04 is_bad_inode 1 3.9e-04 kref_put 1 3.9e-04 lru_add_drain 1 3.9e-04 may_delete 1 3.9e-04 mm_release 1 3.9e-04 n_tty_ioctl 1 3.9e-04 nr_blockdev_pages 1 3.9e-04 page_add_new_anon_rmap 1 3.9e-04 pipe_poll 1 3.9e-04 preempt_schedule_irq 1 3.9e-04 proc_lookup 1 3.9e-04 ptregscall_common 1 3.9e-04 put_files_struct 1 3.9e-04 radix_tree_tag_clear 1 3.9e-04 rb_prev 1 3.9e-04 recalc_bh_state 1 3.9e-04 release_pages 1 3.9e-04 sched_exec 1 3.9e-04 sched_fork 1 3.9e-04 seq_escape 1 3.9e-04 set_close_on_exec 1 3.9e-04 set_fs_pwd 1 3.9e-04 set_personality_64bit 1 3.9e-04 shrink_dcache_parent 1 3.9e-04 sock_map_fd 1 3.9e-04 strchr 1 3.9e-04 submit_bio 1 3.9e-04 sys_dup2 1 3.9e-04 sys_faccessat 1 3.9e-04 sys_munmap 1 3.9e-04 sys_rt_sigaction 1 3.9e-04 tty_write 1 3.9e-04 unlink_file_vma 1 3.9e-04 unlock_page 1 3.9e-04 vfs_read 1 3.9e-04 vfs_readdir 1 3.9e-04 vma_merge 1 3.9e-04 vma_prio_tree_insert 1 3.9e-04 wake_up_new_task 1 3.9e-04 writeback_inodes 1 3.9e-04 zonelist_policy
Quoted 10 lines · Evgeniy Polyakov
They are there, since ab runs only 50k requests.
If I change it to something noticebly more than 50/80k, ab crashes:# ab -c8000 -t 600 -n800000000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Segmentation fault
Quoted 6 lines
Are there any other tool suitable for such loads?
I only tested httperf (which is worse, since it uses poll/select) and 'ab'.Btw, host machine runs 100% too, so it is possible that client side is broken (too).
I have similar problems here, ab test just doesnt complete...
I am still investigating with strace and tcpdump.
In the meantime you could just rewrite it (based on epoll please :) ), since it should be quite easy to do this (reverse of evserver_epoll)
Quoted 15 lines · Eric Dumazet
Quoted 14 lines · Evgeniy Polyakov
They are there, since ab runs only 50k requests.
If I change it to something noticebly more than 50/80k, ab crashes:# ab -c8000 -t 600 -n800000000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Segmentation faultAre there any other tool suitable for such loads?
I only tested httperf (which is worse, since it uses poll/select) and 'ab'.
Quoted 6 lines
Quoted 2 lines
Btw, host machine runs 100% too, so it is possible that client side is broken (too).
I have similar problems here, ab test just doesnt complete...
I am still investigating with strace and tcpdump.
OK... I found it.
I had to loop on accept() :
for (i=0; i<num; ++i) {
if (event[i].data.fd == main_server_s) {
do {
err = evtest_callback_main(event[i].data.fd);
} while (err != -1);
}
else
err = evtest_callback_client(event[i].data.fd);
}Or else we can miss an event forever...
Quoted 37 lines · Eric Dumazet
Quoted 15 lines · Eric Dumazet
Quoted 14 lines · Evgeniy Polyakov
They are there, since ab runs only 50k requests.
If I change it to something noticebly more than 50/80k, ab crashes:# ab -c8000 -t 600 -n800000000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Segmentation faultAre there any other tool suitable for such loads?
I only tested httperf (which is worse, since it uses poll/select) and 'ab'.Quoted 6 lines
Quoted 2 lines
Btw, host machine runs 100% too, so it is possible that client side is broken (too).
I have similar problems here, ab test just doesnt complete...
I am still investigating with strace and tcpdump.
OK... I found it.
I had to loop on
accept():for (i=0; i<num; ++i) { if (event[i].data.fd == main_server_s) { do { err = evtest_callback_main(event[i].data.fd); } while (err != -1); } else err = evtest_callback_client(event[i].data.fd); }
Quoted 1 line
Or else we can miss an event forever...
The same here - I would just enable a debug to find it.
# ab -c8000 -n80000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.0.48 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.27 Server Hostname: 192.168.0.48 Server Port: 80
Document Path: / Document Length: 3521 bytes
Concurrency Level: 8000 Time taken for tests: 18.250921 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 315691904 bytes HTML transferred: 287074172 bytes Requests per second: 4383.34 [#/sec] (mean) Time per request: 1825.092 [ms] (mean) Time per request: 0.228 [ms] (mean, across all concurrent
requests)
Transfer rate: 16891.86 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 137 884 481.1 920 3602 Processing: 567 888 163.6 985 997 Waiting: 47 455 238.2 439 921
Total: 765 1772 566.6 1911 4556
Percentage of the requests served within a certain time (ms)
50% 1911 66% 1911 75% 1912 80% 1913 90% 1913 95% 1914 98% 4438 99% 4497
100% 4556 (longest request)
kano:~#
Signature · 1 line
Evgeniy Polyakov
Quoted 18 lines · Eric Dumazet
Quoted 10 lines · Evgeniy Polyakov
They are there, since ab runs only 50k requests.
If I change it to something noticebly more than 50/80k, ab crashes:# ab -c8000 -t 600 -n800000000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Segmentation faultQuoted 6 lines
Are there any other tool suitable for such loads?
I only tested httperf (which is worse, since it uses poll/select) and 'ab'.Btw, host machine runs 100% too, so it is possible that client side is broken (too).
Quoted 6 lines
I have similar problems here, ab test just doesnt complete...
I am still investigating with strace and tcpdump.
In the meantime you could just rewrite it (based on epoll please :) ), since it should be quite easy to do this (reverse of
evserver_epoll)
Rewriting 'ab' with pure epoll instead of APR lib is like dandruff treatment on a guillotine.
I will try to cook up something own - simple client (based on epoll) tomorrow/weekend, now I need to work for money :)
Signature · 1 line
Evgeniy Polyakov
Oh boy, wasn't this thread supposed to focus the syslets/threadlets ... :)
Quoted 18 lines · Eric Dumazet
Quoted 10 lines · Evgeniy Polyakov
They are there, since ab runs only 50k requests.
If I change it to something noticebly more than 50/80k, ab crashes:# ab -c8000 -t 600 -n800000000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Segmentation faultQuoted 6 lines
Are there any other tool suitable for such loads?
I only tested httperf (which is worse, since it uses poll/select) and 'ab'.Btw, host machine runs 100% too, so it is possible that client side is broken (too).
Quoted 6 lines
I have similar problems here, ab test just doesnt complete...
I am still investigating with strace and tcpdump.
In the meantime you could just rewrite it (based on epoll please :) ), since it should be quite easy to do this (reverse of
evserver_epoll)
I have a simple one based on coroutines and epoll. You need libpcl and coronet. Debian hs a package named libpcl1-dev for libpcl, otherwise:
http://www.xmailserver.org/libpcl.html
and 'configure --prefix=/usr && sudo make install'. Coronet is here:
http://www.xmailserver.org/coronet-lib.html
here just 'configure && make'.
Inside the "test" directory there a simple loader named cnhttpload:
cnhttpload -s HOST -n NCON [-p PORT (80)] [-r NREQS (1)] [-S STKSIZE (8192)]
[-M MAXCONNS] [-t TMUPD (1000)] [-a NACTIVE] [-T TMSAMP (200)]
[-h] URL ...HOST = Target host
PORT = Target host port
NCON = Number of connections to the server
NACTIVE = Number of active (live) connections
STKSIZE = Stack size for coroutines
NREQS = Number of request done for each connection (better be 1 if
your server do not support keep-alive)
MAXCONNS = Maximum number of total connections done to the server. If not
set, the test will continue forever (well, till a ^C)
TMUPD = Millisec time of stats update
TMSAMP = Millisec internal average-update time
URL = Target doc (not http:// or host, just doc path)So for the particular test my inbox was flooded with :), you'd use:
cnhttpload -s HOST -n 80000 -a 8000 -S 4096
- Davide
Quoted 21 lines · Evgeniy Polyakov
Quoted 20 lines · Eric Dumazet
Quoted 3 lines · Evgeniy Polyakov
Could you provide at least remote way to find it?
Sure :)
Quoted 7 lines
I only found the same problem at
http://lkml.org/lkml/2006/10/27/3but without any hits to solve the problem.
I will try CVS oprofile, if it works I will provide details of course.
# cat CVS/Root CVS/Root::pserver:[email protected]:/cvsroot/oprofile# cvs diff >/tmp/oprofile.diff
Quoted 8 lines
Quoted 1 line
Hope it helps
One of the hunks failed, since it was in CVS already. After setting up some mirrors, I've installed all bits needed for oprofile.
Attached kevent and epoll profiles.In that tests I got epoll perf about 4400 req/s, kevent was about 5300.
Attached kevent profile with 6100 req/sec.
They all look exactly the same for me - there no kevent or epoll functions in profiles at all.
Signature · 1 line
Evgeniy Polyakov
CPU: AMD64 processors, speed 2210.08 MHz (estimated)
Counted CPU_CLK_UNHALTED events (Cycles outside of halt state) with a unit mask of 0x00 (No unit mask) count 100000
samples % symbol name 103425 55.0868 cpu_idle 8214 4.3750 enter_idle 4712 2.5097 tcp_v4_rcv 3805 2.0266 IRQ0x51_interrupt 3154 1.6799 tcp_ack 2777 1.4791 kmem_cache_free 2286 1.2176 kfree 2155 1.1478 memset_c 1747 0.9305 csum_partial_copy_generic 1710 0.9108 ip_output 1620 0.8629 dev_queue_xmit 1551 0.8261 handle_IRQ_event 1391 0.7409 schedule 1373 0.7313 tcp_rcv_state_process 1337 0.7121 ip_rcv 1100 0.5859 ip_queue_xmit 965 0.5140 ip_route_input 939 0.5001 tcp_sendmsg 935 0.4980 __do_softirq 923 0.4916 ip_local_deliver 916 0.4879 csum_partial 905 0.4820 system_call 889 0.4735 tcp_transmit_skb 884 0.4708 tcp_v4_do_rcv 812 0.4325 netif_receive_skb 778 0.4144 __d_lookup 760 0.4048 __alloc_skb 747 0.3979 local_bh_enable 737 0.3925 __tcp_push_pending_frames 702 0.3739 kfree_skbmem 698 0.3718 pfifo_fast_enqueue 678 0.3611 kmem_cache_alloc 651 0.3467 fget 640 0.3409 pfifo_fast_dequeue 637 0.3393 net_rx_action 629 0.3350 __link_path_walk 602 0.3206 preempt_schedule 599 0.3190 __fput 594 0.3164 sock_wfree 589 0.3137 copy_user_generic_string 579 0.3084 ret_from_intr 559 0.2977 _atomic_dec_and_lock 552 0.2940 __kfree_skb 549 0.2924 skb_clone 514 0.2738 number 494 0.2631 rt_hash_code 473 0.2519 dput 466 0.2482 tcp_parse_options 446 0.2376 tcp_rcv_established 433 0.2306 tcp_recvmsg 431 0.2296 tcp_poll 417 0.2221 get_unused_fd 417 0.2221 sysret_check 377 0.2008 rb_erase 364 0.1939 __tcp_select_window 363 0.1933 lock_timer_base 347 0.1848 __mod_timer 329 0.1752 ip_append_data 326 0.1736 exit_idle 325 0.1731 ret_from_sys_call 317 0.1688 d_alloc 302 0.1609 do_path_lookup 295 0.1571 __ip_route_output_key 290 0.1545 eth_type_trans 285 0.1518 sys_close 283 0.1507 cache_alloc_refill 282 0.1502 mask_and_ack_8259A 275 0.1465 thread_return 267 0.1422 call_softirq 265 0.1411 tcp_rtt_estimator 260 0.1385 tcp_data_queue 258 0.1374 __dentry_open 258 0.1374 vsnprintf 255 0.1358 dentry_iput 255 0.1358 tcp_current_mss 250 0.1332 sk_stream_mem_schedule 239 0.1273 find_next_zero_bit 233 0.1241 cache_grow 233 0.1241 tcp_send_fin 222 0.1182 try_to_wake_up 219 0.1166 sock_recvmsg 216 0.1150 do_generic_mapping_read 211 0.1124 sys_fcntl 209 0.1113 get_empty_filp 207 0.1103 call_rcu 206 0.1097 strncpy_from_user 195 0.1039 sock_def_readable 190 0.1012 generic_drop_inode 190 0.1012 restore_args 184 0.0980 get_page_from_freelist 182 0.0969 sys_recvfrom 176 0.0937 do_lookup 174 0.0927 common_interrupt 171 0.0911 fget_light 167 0.0889 new_inode 167 0.0889 percpu_counter_mod 166 0.0884 link_path_walk 166 0.0884 skb_checksum 160 0.0852 fput 160 0.0852 release_sock 159 0.0847 memcpy_c 158 0.0842 memcmp 157 0.0836 __skb_checksum_complete 157 0.0836 tcp_init_tso_segs 148 0.0788 half_md4_transform 144 0.0767 tcp_v4_send_check 142 0.0756 del_timer 139 0.0740 current_fs_time 135 0.0719 update_send_head 129 0.0687 do_sys_open 126 0.0671 rb_insert_color 125 0.0666 bictcp_cong_avoid 124 0.0660 __put_unused_fd 123 0.0655 schedule_timeout 121 0.0644 clear_inode 118 0.0628 sock_close 116 0.0618 __do_page_cache_readahead 115 0.0613 alloc_inode 115 0.0613 lookup_mnt 114 0.0607 tcp_snd_test 113 0.0602 mod_timer 112 0.0597 generic_permission 109 0.0581 tcp_select_initial_window 101 0.0538 locks_remove_posix 98 0.0522 fd_install 97 0.0517 find_get_page 97 0.0517 sk_reset_timer 94 0.0501 try_to_del_timer_sync 93 0.0495 __follow_mount 92 0.0490 igrab 91 0.0485 page_cache_readahead 90 0.0479 dnotify_flush 90 0.0479 prepare_to_wait 90 0.0479 put_page 89 0.0474 expand_files 89 0.0474 getname 88 0.0469 inotify_dentry_parent_queue_event 88 0.0469 tcp_sync_mss 87 0.0463 __path_lookup_intent_open 86 0.0458 file_free_rcu 85 0.0453 may_open 85 0.0453 skb_copy_datagram_iovec 84 0.0447 IRQ0x20_interrupt 82 0.0437 tcp_cwnd_validate 81 0.0431 copy_page_c 81 0.0431 d_instantiate 81 0.0431 groups_search 80 0.0426 permission 79 0.0421 __handle_mm_fault 79 0.0421 file_kill 79 0.0421 get_task_mm 76 0.0405 rw_verify_area 74 0.0394 copy_to_user 73 0.0389 __wake_up_bit 72 0.0383 __wake_up 72 0.0383 cond_resched 72 0.0383 mntput_no_expire 69 0.0368 memmove 69 0.0368 sock_sendmsg 69 0.0368 tcp_setsockopt 68 0.0362 open_namei 68 0.0362 retint_kernel 67 0.0357 wake_up_inode 66 0.0352 inet_sendmsg 66 0.0352 tcp_event_data_recv 65 0.0346 generic_file_open 64 0.0341 touch_atime 63 0.0336 sock_release 63 0.0336 tcp_send_ack 62 0.0330 file_move 62 0.0330 filp_close 57 0.0304 mutex_unlock 55 0.0293 inet_sk_rebuild_header 55 0.0293 page_fault 55 0.0293 sockfd_lookup 54 0.0288 memset 54 0.0288 sk_stream_rfree 52 0.0277 __tcp_ack_snd_check 52 0.0277 inode_init_once 52 0.0277 sock_common_recvmsg 52 0.0277 tcp_check_space 51 0.0272 sys_open 49 0.0261 iret_label 47 0.0250 locks_remove_flock 46 0.0245 __rb_rotate_left 46 0.0245 tcp_v4_tw_remember_stamp 46 0.0245 unmap_vmas 45 0.0240 finish_wait 44 0.0234 inet_sock_destruct 44 0.0234 sprintf 43 0.0229 tcp_cong_avoid 42 0.0224 inotify_inode_queue_event 41 0.0218 __alloc_pages 41 0.0218 __lookup_mnt 41 0.0218 _spin_lock_bh 41 0.0218 tcp_init_cwnd 38 0.0202 clear_page_c 38 0.0202 tcp_unhash 37 0.0197 bit_waitqueue 37 0.0197 memcpy_toiovec 36 0.0192 iput 35 0.0186 do_filp_open 35 0.0186 init_timer 35 0.0186 sock_fasync 31 0.0165 __delay 31 0.0165 exit_intr 31 0.0165 vfs_permission 30 0.0160 sk_alloc 29 0.0154 copy_from_user 28 0.0149 free_hot_cold_page 27 0.0144 __put_user_8 27 0.0144 del_timer_sync 27 0.0144 hrtimer_run_queues 26 0.0138 init_once 26 0.0138 sk_stop_timer 25 0.0133 tcp_rcv_space_adjust 25 0.0133 tcp_v4_destroy_sock 23 0.0123 copy_page_range 23 0.0123 find_vma 22 0.0117 blockable_page_cache_readahead 22 0.0117 invalidate_inode_buffers 21 0.0112 do_page_fault 21 0.0112 do_wp_page 20 0.0107 in_group_p 20 0.0107 inet_getname 20 0.0107 mutex_lock 20 0.0107 tcp_slow_start 20 0.0107 zone_watermark_ok 18 0.0096 file_ra_state_init 17 0.0091 mark_page_accessed 16 0.0085 __find_get_block 15 0.0080 rt_run_flush 14 0.0075 __down_read 14 0.0075 __up_read 14 0.0075 apic_timer_interrupt 11 0.0059 destroy_inode 11 0.0059 flush_tlb_page 11 0.0059 vm_normal_page 10 0.0053 error_exit 10 0.0053 memcpy 9 0.0048 __get_user_4 9 0.0048 retint_restore_args 9 0.0048 retint_swapgs 8 0.0043 __rb_rotate_right 8 0.0043 run_local_timers 7 0.0037 error_sti 7 0.0037 inode_has_buffers 7 0.0037 nameidata_to_filp 7 0.0037 timespec_trunc 6 0.0032 __tcp_checksum_complete_user 6 0.0032 _spin_lock_irqsave 6 0.0032 _write_lock_bh 6 0.0032 filemap_nopage 6 0.0032 wake_up_bit 5 0.0027 __getblk 5 0.0027 __iget 5 0.0027 _read_lock_irqsave 5 0.0027 find_vma_prepare 5 0.0027 mmput 4 0.0021 __free_pages 4 0.0021 __mutex_init 4 0.0021 do_mmap_pgoff 4 0.0021 lru_cache_add_active 3 0.0016 __down_read_trylock 3 0.0016 __find_get_block_slow 3 0.0016 __make_request 3 0.0016 __mark_inode_dirty 3 0.0016 __remove_shared_vm_struct 3 0.0016 copy_strings 3 0.0016 do_notify_resume 3 0.0016 free_hot_page 3 0.0016 generic_file_aio_read 3 0.0016 generic_make_request 3 0.0016 load_elf_binary 3 0.0016 page_waitqueue 3 0.0016 prio_tree_insert 3 0.0016 prio_tree_replace 3 0.0016 rcu_start_batch 3 0.0016 unlock_page 3 0.0016 vma_link 3 0.0016 vma_merge 3 0.0016 zonelist_policy 2 0.0011 __block_prepare_write 2 0.0011 __pagevec_lru_add_active 2 0.0011 __put_user_4 2 0.0011 __vma_link_rb 2 0.0011 _read_lock_bh 2 0.0011 alloc_pages_current 2 0.0011 anon_vma_unlink 2 0.0011 copy_process 2 0.0011 d_lookup 2 0.0011 dentry_unhash 2 0.0011 do_mpage_readpage 2 0.0011 do_sigaction 2 0.0011 error_entry 2 0.0011 flush_old_exec 2 0.0011 kmem_flagcheck 2 0.0011 mempool_free 2 0.0011 page_add_file_rmap 2 0.0011 run_workqueue 2 0.0011 sched_balance_self 2 0.0011 set_personality_64bit 2 0.0011 strnlen_user 2 0.0011 sys_mprotect 2 0.0011 sys_rt_sigaction 2 0.0011 vfs_lstat_fd 2 0.0011 worker_thread 1 5.3e-04 __brelse 1 5.3e-04 __d_path 1 5.3e-04 __down_write_nested 1 5.3e-04 __lookup_hash 1 5.3e-04 __page_set_anon_rmap 1 5.3e-04 __strnlen_user 1 5.3e-04 __up_write 1 5.3e-04 __vm_enough_memory 1 5.3e-04 add_timer_randomness 1 5.3e-04 anon_vma_link 1 5.3e-04 bio_alloc_bioset 1 5.3e-04 blk_recount_segments 1 5.3e-04 can_vma_merge_after 1 5.3e-04 cap_bprm_apply_creds 1 5.3e-04 cond_resched_softirq 1 5.3e-04 copy_from_read_buf 1 5.3e-04 cpuset_fork 1 5.3e-04 cpuset_update_task_memory_state 1 5.3e-04 dnotify_parent 1 5.3e-04 do_exit 1 5.3e-04 do_munmap 1 5.3e-04 do_select 1 5.3e-04 do_wait 1 5.3e-04 end_bio_bh_io_sync 1 5.3e-04 exit_sem 1 5.3e-04 file_read_actor 1 5.3e-04 filldir64 1 5.3e-04 find_or_create_page 1 5.3e-04 find_vma_prev 1 5.3e-04 flush_thread 1 5.3e-04 free_pgd_range 1 5.3e-04 free_pgtables 1 5.3e-04 generic_fillattr 1 5.3e-04 get_unmapped_area 1 5.3e-04 inode_sub_bytes 1 5.3e-04 kthread_should_stop 1 5.3e-04 mm_init 1 5.3e-04 path_release 1 5.3e-04 pipe_release 1 5.3e-04 prio_tree_remove 1 5.3e-04 profile_munmap 1 5.3e-04 remove_wait_queue 1 5.3e-04 retint_check 1 5.3e-04 seq_puts 1 5.3e-04 strchr 1 5.3e-04 sys_brk 1 5.3e-04 sys_execve 1 5.3e-04 sys_mmap 1 5.3e-04 sys_munmap 1 5.3e-04 sys_read 1 5.3e-04 sys_rmdir 1 5.3e-04 sys_rt_sigprocmask 1 5.3e-04 truncate_complete_page 1 5.3e-04 tty_ldisc_deref 1 5.3e-04 tty_ldisc_try 1 5.3e-04 tty_termios_baud_rate 1 5.3e-04 tty_write 1 5.3e-04 udp_rcv 1 5.3e-04 vfs_rmdir 1 5.3e-04 vfs_stat_fd 1 5.3e-04 vfs_write 1 5.3e-04 vm_acct_memory 1 5.3e-04 vm_stat_account 1 5.3e-04 vma_adjust 1 5.3e-04 vma_prio_tree_remove 1 5.3e-04 wake_up_new_task
Quoted 2 lines · Eric Dumazet
I used the CVS version of oprofile plus a patch you can find in the mailing list archives. Dont remember exactly, since I hit this some months ago
Ugh, I started - but CVS compilation requires about 40mb of additional libs (according to debian testing dependencies on my very light installation), so with my miserable 1-1.6 kb/sec do not expect it today :)
Signature · 1 line
Evgeniy Polyakov
Quoted 11 lines · Evgeniy Polyakov
Document Length: 3521 bytes
Concurrency Level: 8000 Time taken for tests: 16.686737 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 309760000 bytes HTML transferred: 281680000 bytes Requests per second: 4794.23 [#/sec] (mean)
Quoted 8 lines
Concurrency Level: 8000 Time taken for tests: 12.366775 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 317047104 bytes HTML transferred: 288306522 bytes Requests per second: 6468.95 [#/sec] (mean)
i'm wondering - how can the 'Total transferred' and 'HTML transferred' numbers be different?
Since document length is 3521, and the number of requests is 80000, the correct 'HTML transferred' is 281680000 - which is the epoll result. The kevent result shows more bytes transferred, which suggests that the kevent loop is probably incorrect somewhere.
this might be some benign thing, but the /first/ thing you /have to/ do before claiming that 'kevent is 25% faster than epoll' is to make sure the results are totally reliable.
Ingo
Quoted 26 lines · Ingo Molnar
Quoted 11 lines · Evgeniy Polyakov
Document Length: 3521 bytes
Concurrency Level: 8000 Time taken for tests: 16.686737 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 309760000 bytes HTML transferred: 281680000 bytes Requests per second: 4794.23 [#/sec] (mean)Quoted 8 lines
Concurrency Level: 8000 Time taken for tests: 12.366775 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 317047104 bytes HTML transferred: 288306522 bytes Requests per second: 6468.95 [#/sec] (mean)i'm wondering - how can the 'Total transferred' and 'HTML transferred' numbers be different?
Quoted 8 lines
Since document length is 3521, and the number of requests is 80000, the correct 'HTML transferred' is 281680000 - which is the epoll result. The kevent result shows more bytes transferred, which suggests that the kevent loop is probably incorrect somewhere.
this might be some benign thing, but the /first/ thing you /have to/ do before claiming that 'kevent is 25% faster than epoll' is to make sure the results are totally reliable.
Kevent sent additional 525 pages ((311792800-309760000)/3872) - that is why number for kevent is higher - it uses edge-triggered handler (which you asked to remove from epoll), which can produce false-positives, for absolute result in that case ret_data must be checked where poll flags were stored (before). 'ab' does not count additional data as new requests and does not count them in 'requests per second'.
Even if it could do so, additional 500 requests can not provide 35% higher rate.
For example, lighttpd results are the same for kevent and epoll and 'Total transferred' and 'HTML transferred' numbers change between runs both for epoll and kevent.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 2 lines · Evgeniy Polyakov
[...] that is why number for kevent is higher - it uses edge-triggered handler (which you asked to remove from epoll), [...]
no - i did not 'ask' it to be removed from epoll, i only pointed out that with edge-triggered the results were highly unreliable here and that with level-triggered it worked better. Just to make sure: if you put back edge-triggered into evserver_epoll.c, do you get the same numbers, and is CPU utilization still the same 98-100%?
Ingo
Quoted 11 lines · Ingo Molnar
Quoted 2 lines · Evgeniy Polyakov
[...] that is why number for kevent is higher - it uses edge-triggered handler (which you asked to remove from epoll), [...]
no - i did not 'ask' it to be removed from epoll, i only pointed out that with edge-triggered the results were highly unreliable here and that with level-triggered it worked better. Just to make sure: if you put back edge-triggered into
evserver_epoll.c, do you get the same numbers, and is CPU utilization still the same 98-100%?
No.
_Now_ it is about 1500-2000 req/sec with 10-20% CPU utilization. Number of 'Total transferred' and 'HTML transferred' does not equal to 80000 multiplied by size of the page.
That are strange tests actually - I managed to get 9000 requests per second from epoll server (only once!) and 8900 from kevent (two times only), sometimes they both drop down to 2300-2700 req/s.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
the ab numbers below do not seem that impressive to me, especially for such stripped down server processes.
here are some numbers from a set of test boxes I've got in my lab. I've been useing them to test firewalls, and I've been getting throughput similar to what is listed below when going through a proxy that does a full fork for each connection, and then makes a new connection to the webserver on the other side! the first few sets of numbers are going directly from test client to test server, the final set is going though the proxy.
client and server are dual opteron 252 with 8G of ram, running debian in 64 bit mode
this is with apache2 MPM as the destination (relativly untuned except for tinkering with the child count settings). this should be about as bad as you can get for a server
loadtest2:/proc/sys# ab -c 8000 -n 80000 http://208.2.188.5:80/4k This is ApacheBench, Version 2.0.41-dev <$Revision: 1.141 $> apache-2.0 Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright (c) 1998-2002 The Apache Software Foundation, http://www.apache.org/
Benchmarking 208.2.188.5 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.33 Server Hostname: 208.2.188.5 Server Port: 80
Document Path: /4k Document Length: 4352 bytes
Concurrency Level: 8000 Time taken for tests: 10.992838 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 386192835 bytes HTML transferred: 362612992 bytes Requests per second: 7277.47 [#/sec] (mean) Time per request: 1099.284 [ms] (mean) Time per request: 0.137 [ms] (mean, across all concurrent requests) Transfer rate: 34307.88 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 8 497 1398.3 71 9072 Processing: 17 236 346.9 103 2995 Waiting: 8 91 131.6 65 1692 Total: 26 734 1435.5 187 9786
Percentage of the requests served within a certain time (ms)
50% 187 66% 288 75% 564 80% 754 90% 3085 95% 3163 98% 4316 99% 9186 100% 9786 (longest request) loadtest2:/proc/sys# ab -c 8000 -n 80000 http://208.2.188.5:80/8k This is ApacheBench, Version 2.0.41-dev <$Revision: 1.141 $> apache-2.0 Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright (c) 1998-2002 The Apache Software Foundation, http://www.apache.org/
Benchmarking 208.2.188.5 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.33 Server Hostname: 208.2.188.5 Server Port: 80
Document Path: /8k Document Length: 8704 bytes
Concurrency Level: 8000 Time taken for tests: 11.355031 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 736949141 bytes HTML transferred: 713733802 bytes Requests per second: 7045.34 [#/sec] (mean) Time per request: 1135.503 [ms] (mean) Time per request: 0.142 [ms] (mean, across all concurrent requests) Transfer rate: 63379.48 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 36 495 1297.1 76 9056 Processing: 81 317 529.5 161 3448 Waiting: 25 89 75.1 76 1610 Total: 124 812 1401.5 250 11011
Percentage of the requests served within a certain time (ms)
50% 250 66% 304 75% 497 80% 705 90% 3171 95% 3251 98% 3455 99% 9160
100% 11011 (longest request)
for both of these tests the server had it's cpu maxed out (<5% idle)
switching to thttpd instead of apache and I get
loadtest2:/proc/sys# ab -c 8000 -n 80000 http://208.2.188.5:81/4k This is ApacheBench, Version 2.0.41-dev <$Revision: 1.141 $> apache-2.0 Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright (c) 1998-2002 The Apache Software Foundation, http://www.apache.org/
Benchmarking 208.2.188.5 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: thttpd/2.23beta1 Server Hostname: 208.2.188.5 Server Port: 81
Document Path: /4k Document Length: 4352 bytes
Concurrency Level: 8000 Time taken for tests: 9.944605 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 372748950 bytes HTML transferred: 352729600 bytes Requests per second: 8044.56 [#/sec] (mean) Time per request: 994.461 [ms] (mean) Time per request: 0.124 [ms] (mean, across all concurrent requests) Transfer rate: 36603.97 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 50 324 1274.4 70 9124 Processing: 68 98 33.3 90 781 Waiting: 22 69 26.9 63 729 Total: 125 423 1291.9 161 9324
Percentage of the requests served within a certain time (ms)
50% 161 66% 175 75% 188 80% 203 90% 246 95% 307 98% 3243 99% 9272 100% 9324 (longest request) loadtest2:/proc/sys# ab -c 8000 -n 80000 http://208.2.188.5:81/8k This is ApacheBench, Version 2.0.41-dev <$Revision: 1.141 $> apache-2.0 Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright (c) 1998-2002 The Apache Software Foundation, http://www.apache.org/
Benchmarking 208.2.188.5 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: thttpd/2.23beta1 Server Hostname: 208.2.188.5 Server Port: 81
Document Path: /8k Document Length: 8704 bytes
Concurrency Level: 8000 Time taken for tests: 13.502031 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 729161888 bytes HTML transferred: 709030153 bytes Requests per second: 5925.03 [#/sec] (mean) Time per request: 1350.203 [ms] (mean) Time per request: 0.169 [ms] (mean, across all concurrent requests) Transfer rate: 52738.14 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 46 338 1189.7 106 9145 Processing: 79 197 52.8 195 670 Waiting: 39 92 28.4 94 577 Total: 140 536 1208.3 293 9424
Percentage of the requests served within a certain time (ms)
50% 293 66% 350 75% 355 80% 369 90% 388 95% 3293 98% 3388 99% 9392 100% 9424 (longest request)
for these the CPU is ~45% idle on the server box.
now if I go through a box in the middle running a proxy that forks for every request (so you have two seperate TCP connections, plus a fork for each request plus two writes to syslog) the proxy box is a dual opteron 252 with 4G or ram running debian 32 bit
loadtest2:/proc/sys# ab -c 8000 -n 80000 http://192.168.254.2:8080/8k This is ApacheBench, Version 2.0.41-dev <$Revision: 1.141 $> apache-2.0 Copyright (c) 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright (c) 1998-2002 The Apache Software Foundation, http://www.apache.org/
Benchmarking 192.168.254.2 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requests
Server Software: Apache/1.3.33 Server Hostname: 192.168.254.2 Server Port: 8080
Document Path: /8k Document Length: 8704 bytes
Concurrency Level: 8000 Time taken for tests: 21.101321 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 721092650 bytes HTML transferred: 698383315 bytes Requests per second: 3791.23 [#/sec] (mean) Time per request: 2110.132 [ms] (mean) Time per request: 0.264 [ms] (mean, across all concurrent requests) Transfer rate: 33371.94 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 9 621 1652.3 20 9036 Processing: 28 81 195.5 50 6652 Waiting: 9 51 195.5 19 6620 Total: 38 703 1683.2 70 12291
Percentage of the requests served within a certain time (ms)
50% 70 66% 80 75% 83 80% 101 90% 3075 95% 3088 98% 9073 99% 9087
100% 12291 (longest request)
David Lang
Quoted 150 lines · Evgeniy Polyakov
Quoted 7 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
I posted kevent/epoll benchmarks and related design issues too many times both with handmade applications (which might be broken as hell) and popular open-source servers to repeat them again.
Quoted 10 lines
numbers are crutial here - and given the epoll bugs in the evserver code that we found, do you have updated evserver benchmark results that compare epoll to kevent? I'm wondering why epoll has half the speed of kevent in those measurements - i suspect some possible benchmarking bug. The queueing model of epoll and kevent is roughly comparable, both do only a constant number of steps to serve one particular request, regardless of how many pending connections/requests there are. What is the CPU utilization of the server system during an epoll test, and what is the CPU utilization during a kevent test? 100% utilized in both cases?
Yes, it is about 98-100% in both cases.
I've just re-run tests on my amd64 test machine without debug options:epoll 4794.23
kevent 6468.95here are full client 'ab' outputs for epoll and kevent servers (epoll does not contain EPOLLET as you requested, but it does not look like it change performance in my case).
epoll ab aoutput:
# ab -c8000 -n80000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requestsServer Software: Apache/1.3.27 Server Hostname: 192.168.0.48 Server Port: 80Document Path: / Document Length: 3521 bytesConcurrency Level: 8000 Time taken for tests: 16.686737 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 309760000 bytes HTML transferred: 281680000 bytes Requests per second: 4794.23 [#/sec] (mean) Time per request: 1668.674 [ms] (mean) Time per request: 0.209 [ms] (mean, across all concurrentrequests)
Transfer rate: 18128.17 [Kbytes/sec] receivedConnection Times (ms)
min mean[+/-sd] median maxConnect: 159 779 110.1 799 921 Processing: 468 866 77.4 869 988 Waiting: 63 426 212.3 425 921 Total: 1145 1646 115.6 1660 1873Percentage of the requests served within a certain time (ms)
50% 1660 66% 1661 75% 1662 80% 1663 90% 1806 95% 1830 98% 1833 99% 1834100% 1873 (longest request)
kevent ab output:
# ab -c8000 -n80000 http://192.168.0.48/ This is ApacheBench, Version 2.0.40-dev <$Revision: 1.146 $> apache-2.0 Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/ Copyright 2006 The Apache Software Foundation, http://www.apache.org/Benchmarking 192.168.0.48 (be patient)
Completed 8000 requests
Completed 16000 requests
Completed 24000 requests
Completed 32000 requests
Completed 40000 requests
Completed 48000 requests
Completed 56000 requests
Completed 64000 requests
Completed 72000 requests
Finished 80000 requestsServer Software: Apache/1.3.27 Server Hostname: 192.168.0.48 Server Port: 80Document Path: / Document Length: 3521 bytesConcurrency Level: 8000 Time taken for tests: 12.366775 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 317047104 bytes HTML transferred: 288306522 bytes Requests per second: 6468.95 [#/sec] (mean) Time per request: 1236.677 [ms] (mean) Time per request: 0.155 [ms] (mean, across all concurrentrequests)
Transfer rate: 25036.12 [Kbytes/sec] receivedConnection Times (ms)
min mean[+/-sd] median maxConnect: 130 364 871.1 275 9347 Processing: 178 298 42.5 296 580 Waiting: 31 202 65.8 210 369 Total: 411 663 887.0 572 9722Percentage of the requests served within a certain time (ms)
50% 572 66% 573 75% 618 80% 640 90% 684 95% 709 98% 72199% 3455
100% 9722 (longest request)Notice how percentage of the requests served within a certain time differs for kevent and epoll. And this server does not include ready-on-submission kevent optimization.
Quoted 1 line
Ingo
Quoted 2 lines · David Lang
the ab numbers below do not seem that impressive to me, especially for such stripped down server processes.
...
Quoted 2 lines
client and server are dual opteron 252 with 8G of ram, running debian in 64 bit mode
Decrease your hardware setup in 2-4 times, leave only one apache process and try to get the same - we are not talking about how to create a perfect web server, instead we try to focus possible problems in epoll/kevent event driven logic.
Vanilla (epoll) lighttpd shows 4000-5000 requests per second in my setup (no logs). Default mpm-apache2 with bunch of threads - about 8k req/s.
Default thttpd (disabled logging) - about 2k req/s
Btw, all your tests are network bound, try to decrease
html page size to get actual event processing speed out of that machines.
Signature · 1 line
Evgeniy Polyakov
Quoted 11 lines · Evgeniy Polyakov
Quoted 2 lines · David Lang
the ab numbers below do not seem that impressive to me, especially for such stripped down server processes.
...
Quoted 2 lines
client and server are dual opteron 252 with 8G of ram, running debian in 64 bit mode
Decrease your hardware setup in 2-4 times, leave only one apache process and try to get the same - we are not talking about how to create a perfect web server, instead we try to focus possible problems in epoll/kevent event driven logic.
for apache I agree that the target box was maxed out, so if you only had a single core on your AMD64 box that would be about half, however the thttpd is only useing ~1 of the CPU's (OS overhead is useing just a smidge of the second, but overall the box is 45-48% idle
if the amount of ram is an issue then you are swapping in your tests (or at least throwing out cache that you need) and so would not be testing what you think you are.
Quoted 6 lines
Vanilla (epoll) lighttpd shows 4000-5000 requests per second in my setup (no logs). Default mpm-apache2 with bunch of threads - about 8k req/s.
Default thttpd (disabled logging) - about 2k req/sBtw, all your tests are network bound, try to decrease
html page size to get actual event processing speed out of that machines.
same test retreiving a ~128b file the server never gets below 51% idle (so it's only useing one CPU)
Server Software: thttpd/2.23beta1 Server Hostname: 208.2.188.5 Server Port: 81
Document Path: /128b Document Length: 136 bytes
Concurrency Level: 8000 Time taken for tests: 9.372902 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 30762842 bytes HTML transferred: 10952216 bytes Requests per second: 8535.24 [#/sec] (mean) Time per request: 937.290 [ms] (mean) Time per request: 0.117 [ms] (mean, across all concurrent requests) Transfer rate: 3205.09 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max Connect: 36 287 1125.6 73 9109 Processing: 49 89 19.8 87 339 Waiting: 17 62 16.4 62 292 Total: 92 376 1137.4 159 9262
Percentage of the requests served within a certain time (ms)
50% 159 66% 164 75% 165 80% 165 90% 203 95% 260 98% 3233 99% 9201 100% 9262 (longest request)
note that this is showing the slowdown from the large concurrancy level, if I reduce the concurrancy level to 500 I get
Document Path: /128b Document Length: 136 bytes
Concurrency Level: 500 Time taken for tests: 4.215025 seconds Complete requests: 80000 Failed requests: 0 Write errors: 0 Total transferred: 30565348 bytes HTML transferred: 10881904 bytes Requests per second: 18979.72 [#/sec] (mean) Time per request: 26.344 [ms] (mean) Time per request: 0.053 [ms] (mean, across all concurrent requests) Transfer rate: 7081.33 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 15 206.3 1 3006 Processing: 2 7 6.4 6 224 Waiting: 1 6 6.4 5 224 Total: 3 22 208.4 6 3229
Percentage of the requests served within a certain time (ms)
50% 6
66% 8
75% 10 80% 12 90% 16 95% 17 98% 21 99% 24
100% 3229 (longest request)
loadtest2:/proc/sys#
again with >50% idle on the server box
also, ab appears to only use a single cpu so the fact that there are two on the client box should not make a difference.
I will reboot these boxes into a UP kernel if you think that this is still a significant difference. based on what I'm seeing I don't think it will make much of a difference (except for the apache test)
David Lang
Quoted 7 lines · Ingo Molnar
Quoted 3 lines · Evgeniy Polyakov
I posted kevent/epoll benchmarks and related design issues too many times both with handmade applications (which might be broken as hell) and popular open-source servers to repeat them again.
Quoted 10 lines
numbers are crutial here - and given the epoll bugs in the evserver code that we found, do you have updated evserver benchmark results that compare epoll to kevent? I'm wondering why epoll has half the speed of kevent in those measurements - i suspect some possible benchmarking bug. The queueing model of epoll and kevent is roughly comparable, both do only a constant number of steps to serve one particular request, regardless of how many pending connections/requests there are. What is the CPU utilization of the server system during an epoll test, and what is the CPU utilization during a kevent test? 100% utilized in both cases?
With 8K concurrent (live) connections, we may also want to try with the v3 version of the epoll-event-loops-diet patch ;)
- Davide
Hi!
Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
Quoted 1 line
10% gain in speed is NOT worth major complexity increase.
Should I create a patch to remove rb-tree implementation?
Quoted 8 lines
Quoted 4 lines
If you can replace them with something simpler, and no worse than 10% slower in worst case, then go ahead. (We actually tried to do that at some point, only to realize that efence stresses vm subsystem in very unexpected/unfriendly way).
Agh, only 10% in the worst case.
I think you can not even imagine what tricks network uses to get at least aditional 1% out of the box.
Yep? Feel free to rewrite networking to assembly on Eugenix. That should get you 1% improvement. If you reserve few registers to be only used by kernel (not allowed by userspace), you can speedup networking 5%, too. Ouch and you could turn off MMU, that is sure way to get few more percent improvement in your networking case.
Quoted 2 lines
Using such logic you can just abandon any further development, since it work as is right now.
Stop trying to pervert my logic.
Quoted 9 lines
Quoted 6 lines
Quoted 1 line
That practice is stupid IMO.
Too bad. Now you can start Linux fork called Eugenix.
(But really, Linux is not "maximum performance at any cost". Linux is "how fast can we get that while keeping it maintainable?").
Should I read it like: we do not understand what it is and thus we do not want it?
Actually, yes, that's a concern. If your code is so crappy that we can't understand it, guess what, it is not going to be merged. Notice that someone will have to maintain your code if you get hit by bus.
If your code is so complex that it is almost impossible to use from userspace, that is good enough reason not to be merged. "But it is 3% faster if..." is not a good-enough argument.
Quoted 8 lines
Quoted 5 lines
That is why, while arguing syslets vs. kevents, you need need to argue not "kevents are faster because they avoid context switch overhead", but "kevents are
_somuch_faster that it is worth the added complexity". And Ingo seems to showing you they are not_somuch_faster.Threadlets behave much worse without event driven model, events can behave worse without backed threads, they are mutually compensating.
I think Ingo demonstrated unoptimized threadlets to be within 5% to the speed of kevent. Demonstrate that kevents are twice faster than syslets on reasonable test case, and I guess we'll listen...
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 5 lines · Pavel Machek
Quoted 2 lines
Threadlets behave much worse without event driven model, events can behave worse without backed threads, they are mutually compensating.
I think Ingo demonstrated unoptimized threadlets to be within 5% to the speed of kevent. [...]
that was epoll not kevent, but yeah. To me the biggest question is, how much improvement does kevent bring relative to epoll? Epoll is a pretty good event queueing API, and it covers all the event sources today. It is also O(1) throughout, so i dont really understand how it could only achieve half the speed of kevent in the evserver_epoll/kevent.c benchmark. We need to understand that first.
Ingo
Quoted 13 lines · Pavel Machek
Quoted 4 lines
Quoted 4 lines
Quoted 3 lines
Quoted 1 line
10% gain in speed is NOT worth major complexity increase.
Should I create a patch to remove rb-tree implementation?
Quoted 8 lines
Quoted 4 lines
If you can replace them with something simpler, and no worse than 10% slower in worst case, then go ahead. (We actually tried to do that at some point, only to realize that efence stresses vm subsystem in very unexpected/unfriendly way).
Agh, only 10% in the worst case.
I think you can not even imagine what tricks network uses to get at least aditional 1% out of the box.
Quoted 5 lines
Yep? Feel free to rewrite networking to assembly on Eugenix. That should get you 1% improvement. If you reserve few registers to be only used by kernel (not allowed by userspace), you can speedup networking 5%, too. Ouch and you could turn off MMU, that is sure way to get few more percent improvement in your networking case.
It is not _my_ networking, but taht one you use everyday in every Linux box. Notice which tricks are used to remove single byte from sk_buff. It is called optimization, and if it does us a single plus it must be implemented. Not all people have magical fear of new things.
Quoted 4 lines
Quoted 2 lines
Using such logic you can just abandon any further development, since it work as is right now.
Stop trying to pervert my logic.
Ugh? :)
I just say in simple words your 'we do not need something if adds 10%, but is complex to understand'.
Quoted 10 lines
Quoted 9 lines
Quoted 6 lines
Quoted 1 line
That practice is stupid IMO.
Too bad. Now you can start Linux fork called Eugenix.
(But really, Linux is not "maximum performance at any cost". Linux is "how fast can we get that while keeping it maintainable?").
Should I read it like: we do not understand what it is and thus we do not want it?
Quoted 7 lines
Actually, yes, that's a concern. If your code is so crappy that we can't understand it, guess what, it is not going to be merged. Notice that someone will have to maintain your code if you get hit by bus.
If your code is so complex that it is almost impossible to use from userspace, that is good enough reason not to be merged. "But it is 3% faster if..." is not a good-enough argument.
Is it enough for you?
epoll 4794.23 req/sec
kevent 6468.95 req/sec
And we are not saying about other kevent features like ability to deliver essentially any event through its queue or shared ring (and a some of its ideas are being slowly implemented in syslet/threadlet code, btw).
Even if kevent is as fast as epoll, it allows to work with any kind of events (signals, timers, aio completion, io events and any other you like) with one queue/ring, which removes races and does _simplofy_ development, since there is no need to create different models to handle different events.
Quoted 6 lines
Quoted 6 lines
Quoted 5 lines
That is why, while arguing syslets vs. kevents, you need need to argue not "kevents are faster because they avoid context switch overhead", but "kevents are
_somuch_faster that it is worth the added complexity". And Ingo seems to showing you they are not_somuch_faster.
Quoted 6 lines
Quoted 2 lines
Threadlets behave much worse without event driven model, events can behave worse without backed threads, they are mutually compensating.
I think Ingo demonstrated unoptimized threadlets to be within 5% to the speed of kevent. Demonstrate that kevents are twice faster than syslets on reasonable test case, and I guess we'll listen...
That was compared to epoll, not kevent.
But I repeat again - kevent is not only epoll, it can do a lot of ther things which does improve performance and simplify development - did you saw terrible hacks in libevent to handle signals without race in polling loop? It is not needed anymore completely - one event loop, one event structure, completely unified interface for all operations. Some kevent features are slowly being implemented in syslet/threadlet async code too, and it looks like I see where things will end up :), but likely I do not care about new 'kevent', I just wanted that that was said half a year ago, when I started its resending again, but Ingo already said his definitive word :)
Quoted 4 lines
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Signature · 1 line
Evgeniy Polyakov
Hi!
Quoted 15 lines
Quoted 9 lines
Quoted 8 lines
Quoted 4 lines
If you can replace them with something simpler, and no worse than 10% slower in worst case, then go ahead. (We actually tried to do that at some point, only to realize that efence stresses vm subsystem in very unexpected/unfriendly way).
Agh, only 10% in the worst case.
I think you can not even imagine what tricks network uses to get at least aditional 1% out of the box.Quoted 5 lines
Yep? Feel free to rewrite networking to assembly on Eugenix. That should get you 1% improvement. If you reserve few registers to be only used by kernel (not allowed by userspace), you can speedup networking 5%, too. Ouch and you could turn off MMU, that is sure way to get few more percent improvement in your networking case.
Quoted 3 lines
It is not _my_ networking, but taht one you use everyday in every Linux box. Notice which tricks are used to remove single byte from
sk_buff.
Ok, so tricks were worth it in sk_buff case.
Quoted 2 lines
It is called optimization, and if it does us a single plus it must be implemented. Not all people have magical fear of new things.
But that does not mean "every optimalization must be implemented". Only optimalizations that are "worth it" are...
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
Using such logic you can just abandon any further development, since it work as is right now.
Stop trying to pervert my logic.
Ugh? :)
I just say in simple words your 'we do not need something if adds 10%, but is complex to understand'.
Yes... but that does not mean "stop development". You are still free to clean up the code _while_ making it faster.
Quoted 8 lines
Quoted 3 lines
If your code is so complex that it is almost impossible to use from userspace, that is good enough reason not to be merged. "But it is 3% faster if..." is not a good-enough argument.
Is it enough for you?
epoll 4794.23 req/sec
kevent 6468.95 req/sec
Maybe. It is not up to me to decide. But "it is faster" is _not_ the only merge criterium.
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Quoted 2 lines · Pavel Machek
Maybe. It is not up to me to decide. But "it is faster" is _not_ the only merge criterium.
Of course not!
Even if kevent has the same speed, it still allows to handle _any_ kind of events without any major surgery - a very tiny structure of lock and list head and you can process your own kernel event in userspace with timers, signals, io events, private userspace events and others without races and invention of differnet hacks for different types - _this_ is main point.
Quoted 4 lines
Pavel
Signature · 2 lines
(english) http://www.livejournal.com/~pavelmachek (cesky, pictures) http://atrey.karlin.mff.cuni.cz/~pavel/picture/horses/blog.html
Signature · 1 line
Evgeniy Polyakov
Quoted 6 lines · Evgeniy Polyakov
Even if kevent has the same speed, it still allows to handle _any_ kind of events without any major surgery - a very tiny structure of lock and list head and you can process your own kernel event in userspace with timers, signals, io events, private userspace events and others without races and invention of differnet hacks for different types - _this_ is main point.
did it ever occur to you to ... extend epoll? To speed it up? To add a new wait syscall to it? Instead of introducing a whole new parallel framework?
Ingo
Quoted 10 lines · Ingo Molnar
Quoted 6 lines · Evgeniy Polyakov
Even if kevent has the same speed, it still allows to handle _any_ kind of events without any major surgery - a very tiny structure of lock and list head and you can process your own kernel event in userspace with timers, signals, io events, private userspace events and others without races and invention of differnet hacks for different types - _this_ is main point.
Quoted 3 lines
did it ever occur to you to ... extend epoll? To speed it up? To add a new wait syscall to it? Instead of introducing a whole new parallel framework?
Yes, I thought about its extension more than a year ago before started kevent, but epoll() is absolutely based on file structure and its file_operations with poll methodt, so it is quite impossible to work with sockets to implement network AIO. Eventually it had gathered a lot of other systems - do we really want to have per process signalfs, timerfs and so on - each simple structure must be bound to a file, which becomes too cost.
Quoted 1 line
Ingo
Signature · 1 line
Evgeniy Polyakov
Quoted 2 lines · Evgeniy Polyakov
do we really want to have per process signalfs, timerfs and so on - each simple structure must be bound to a file, which becomes too cost.
I may be old school, but if you ask me, and if you *really* want those events, yes. Reason? Unix's everything-is-a-file rule, and being able to use them with *existing* POSIX poll/select. Remember, not every app requires huge scalability efforts, so working with simpler and familiar APIs is always welcome.
The *only* thing that was not practical to have as fd, was block requests. But maybe threadlets/syslets will handle those just fine, and close the gap.
- Davide
Quoted 5 lines · Davide Libenzi
Quoted 2 lines · Evgeniy Polyakov
do we really want to have per process signalfs, timerfs and so on - each simple structure must be bound to a file, which becomes too cost.
Quoted 7 lines
I may be old school, but if you ask me, and if you *really* want those events, yes. Reason? Unix's everything-is-a-file rule, and being able to use them with *existing* POSIX poll/select. Remember, not every app requires huge scalability efforts, so working with simpler and familiar APIs is always welcome.
The *only* thing that was not practical to have as fd, was block requests. But maybe threadlets/syslets will handle those just fine, and close the gap.
That means that we bind very small object like timer or signal to the whoe file structure - yes, as I stated - it is doable, but do we really have to create a file each time create_timer() or signal() is called? Signals as a filesystem are limited in that regard that we need to create additional structures to have signal number<->private data relations.
I designed kevent to be as small as possible, so I removed file binding idea first. I do not say it is wrong or epoll (and threadlets) are broken (fsck, I hope people do understand that), but as is it can not handle that scenario, so it must be extended and/or a lot of other stuff written to be compatible with epoll design. Kevent has different design (which allows to work with old one though - there is a patch to implement epoll over kevent).
Quoted 2 lines
- Davide
Signature · 1 line
Evgeniy Polyakov
Quoted 14 lines · Eric Dumazet
Quoted 14 lines
I had to loop on
accept():for (i=0; i<num; ++i) { if (event[i].data.fd == main_server_s) { do { err = evtest_callback_main(event[i].data.fd); } while (err != -1); } else err = evtest_callback_client(event[i].data.fd); }Or else we can miss an event forever...
Quoted 3 lines · Evgeniy Polyakov
The same here - I would just enable a debug to find it.
I reported this a while ago and suggested to have the number of pending accepts reported with the event to save that last syscall.
I created an ab replacement based on kevent, and at least with my machines, which are comparable to each other, the load on client dropped from 100% to 2% or something. ab just doesn't give meaningful results (if the client is not way more powerful). With that new client I get very similar results for epoll and kevent, from 1000 through to 26000 concurrent requests, the results have been posted on kevent-homepage in october, I just checked it with new version, but there's no significant difference.
this is the benchmark with kevent-based client:
http://tservice.net.ru/~s0mbre/blog/2006/10/11#2006_10_11
btw, each result is average over 1,000,000 requests
and just for comparison, this is on the same machines using ab:
http://tservice.net.ru/~s0mbre/blog/2006/10/08#2006_10_08
Quoted 9 lines · Johann Borck
I reported this a while ago and suggested to have the number of pending accepts reported with the event to save that last syscall.
I created an ab replacement based on kevent, and at least with my machines, which are comparable to each other, the load on client dropped from 100% to 2% or something. ab just doesn't give meaningful results (if the client is not way more powerful). With that new client I get very similar results for epoll and kevent, from 1000 through to 26000 concurrent requests, the results have been posted on kevent-homepage in october, I just checked it with new version, but there's no significant difference.this is the benchmark with kevent-based client:
http://tservice.net.ru/~s0mbre/blog/2006/10/11#2006_10_11
btw, each result is average over 1,000,000 requestsand just for comparison, this is on the same machines using ab:
http://tservice.net.ru/~s0mbre/blog/2006/10/08#2006_10_08
is this client avaialble? and what patches need to be added to the kernel to use it?
David Lang
Quoted 6 lines · David Lang
Quoted 3 lines · Johann Borck
I reported this a while ago and suggested to have the number of pending accepts reported with the event to save that last syscall.
I created an ab replacement based on kevent, and at least with my machines, which are comparable to each other, the load on client dropped from 100% to 2% or something. ab just doesn't give meaningful results (if the client is not way more powerful). With that new client I get very similar results for epoll and kevent, from 1000 through to 26000 concurrent requests, the results have been posted on kevent-homepage in october, I just checked it with new version, but there's no significant difference.
Quoted 9 lines
Quoted 6 lines
this is the benchmark with kevent-based client:
http://tservice.net.ru/~s0mbre/blog/2006/10/11#2006_10_11
btw, each result is average over 1,000,000 requestsand just for comparison, this is on the same machines using ab:
http://tservice.net.ru/~s0mbre/blog/2006/10/08#2006_10_08is this client avaialble? and what patches need to be added to the kernel to use it?
It's based on an older version of kevent, so I'll have to adapt it a bit for use with recent patch, no other than kevent is necessary. I'll post a link when it's cleaned up, if you want.
Johann
Quoted 2 lines
David Lang