Thread: non blocking io

What operating system will your scgi library be running on?

The second one is saving pointer to function which will be executed on readines of the io, save data in user defined structure pointed to by special "void *user_data" field, and wait for another event, upon which, execute specified "next function". But this is complex and inconvinient. What would you suggest?

this is similar to how node.js works (which uses libuv, which is like libev but is portable to linux and windows). seems complex at first to those used to linear programs, but once figured out, becomes effective.

After reading more about libev, seems like pointer to function would be the way to go. When the user's function is called, is there some synchronization method that would allow the function to set an event that the main user code could be pending on? In other situations, sometimes instead of using non-blocking io, multi-threading is used instead with some threads dedicated for blocked io operations (while the other threads continue to run), and then using the normal synchronization methods like mutexes or semaphores. Is this not a reasonable approach for your particular application?

But this is complex and inconvinient. What would you suggest?

O_o

Actually, I find that iterating over "ready", "fill", and "next" events, or similar, is one of the few ways correctly exposing asynchronous facilities.

As dmh2000 says, it may seem complex at first, but after the client understands how to handle the cycle it is very natural.

Is this not a reasonable approach for your particular application?

O_o

Well, though it depends on the underlying operating system, using asynchronous events is generally faster than threading approaches.

Take a look at your suggest; you are basically building a synchronous mechanism using several different events. If you can use the asynchronous primitives directly, you will not need to pay the price of those synchronization primitives.

Soma

The target OS is linux of course.
The main downside in convinience I see in next function approach - good bye stack variables.
I would use the threaded method, if I didn't have goal of making it purely event driven.
Is there really no other options?

Originally Posted by wirmius

... linux ... I would use the threaded method, if I didn't have goal of making it purely event driven.

Assuming this is a preemptive version of linux, then why wouldn't you consider multi-threading to be event driven? If a higher priority thread is pending on an event signalled by a thread performing the blocked io, then a context switch will occur as soon as the event is signalled. Isn't that good enough?