… | |
… | |
53 | |
53 | |
54 | For example the deliantra game server uses a variant of this technique |
54 | For example the deliantra game server uses a variant of this technique |
55 | to interrupt background processes regularly to send map updates to game |
55 | to interrupt background processes regularly to send map updates to game |
56 | clients. |
56 | clients. |
57 | |
57 | |
|
|
58 | Or L<EV::Loop::Async> uses an interrupt object to wake up perl when new |
|
|
59 | events have arrived. |
|
|
60 | |
58 | L<IO::AIO> and L<BDB> could also use this to speed up result reporting. |
61 | L<IO::AIO> and L<BDB> could also use this to speed up result reporting. |
59 | |
62 | |
60 | =item Speedy event loop invocation |
63 | =item Speedy event loop invocation |
61 | |
64 | |
62 | One could use this module e.g. in L<Coro> to interrupt a running coro-thread |
65 | One could use this module e.g. in L<Coro> to interrupt a running coro-thread |
… | |
… | |
162 | which case the requirements set out for C<cb> apply as well). |
165 | which case the requirements set out for C<cb> apply as well). |
163 | |
166 | |
164 | =item var => $scalar_ref |
167 | =item var => $scalar_ref |
165 | |
168 | |
166 | When specified, then the given argument must be a reference to a |
169 | When specified, then the given argument must be a reference to a |
167 | scalar. The scalar will be set to C<0> intiially. Signalling the interrupt |
170 | scalar. The scalar will be set to C<0> initially. Signalling the interrupt |
168 | object will set it to the passed value, handling the interrupt will reset |
171 | object will set it to the passed value, handling the interrupt will reset |
169 | it to C<0> again. |
172 | it to C<0> again. |
170 | |
173 | |
171 | Note that the only thing you are legally allowed to do is to is to check |
174 | Note that the only thing you are legally allowed to do is to is to check |
172 | the variable in a boolean or integer context (e.g. comparing it with a |
175 | the variable in a boolean or integer context (e.g. comparing it with a |
… | |
… | |
214 | bless \(_alloc $arg{cb}, @{$arg{c_cb}}[0,1], @{$arg{pipe}}[0,1], $arg{signal}, $arg{var}), $class |
217 | bless \(_alloc $arg{cb}, @{$arg{c_cb}}[0,1], @{$arg{pipe}}[0,1], $arg{signal}, $arg{var}), $class |
215 | } |
218 | } |
216 | |
219 | |
217 | =item ($signal_func, $signal_arg) = $async->signal_func |
220 | =item ($signal_func, $signal_arg) = $async->signal_func |
218 | |
221 | |
219 | Returns the address of a function to call asynchronously. The function has |
222 | Returns the address of a function to call asynchronously. The function |
220 | the following prototype and needs to be passed the specified C<$c_arg>, |
223 | has the following prototype and needs to be passed the specified |
221 | which is a C<void *> cast to C<IV>: |
224 | C<$signal_arg>, which is a C<void *> cast to C<IV>: |
222 | |
225 | |
223 | void (*signal_func) (void *signal_arg, int value) |
226 | void (*signal_func) (void *signal_arg, int value) |
224 | |
227 | |
225 | An example call would look like: |
228 | An example call would look like: |
226 | |
229 | |
… | |
… | |
264 | ; // do something |
267 | ; // do something |
265 | |
268 | |
266 | =item $async->signal ($value=1) |
269 | =item $async->signal ($value=1) |
267 | |
270 | |
268 | This signals the given async object from Perl code. Semi-obviously, this |
271 | This signals the given async object from Perl code. Semi-obviously, this |
269 | will instantly trigger the callback invocation. |
272 | will instantly trigger the callback invocation (it does not, as the name |
|
|
273 | might imply, do anything with POSIX signals). |
270 | |
274 | |
271 | C<$value> must be in the valid range for a C<sig_atomic_t>, except C<0> |
275 | C<$value> must be in the valid range for a C<sig_atomic_t>, except C<0> |
272 | (1..127 is portable). |
276 | (1..127 is portable). |
|
|
277 | |
|
|
278 | =item $async->signal_hysteresis ($enable) |
|
|
279 | |
|
|
280 | Enables or disables signal hysteresis (default: disabled). If a POSIX |
|
|
281 | signal is used as a signal source for the interrupt object, then enabling |
|
|
282 | signal hysteresis causes Async::Interrupt to reset the signal action to |
|
|
283 | C<SIG_IGN> in the signal handler and restore it just before handling the |
|
|
284 | interruption. |
|
|
285 | |
|
|
286 | When you expect a lot of signals (e.g. when using SIGIO), then enabling |
|
|
287 | signal hysteresis can reduce the number of handler invocations |
|
|
288 | considerably, at the cost of two extra syscalls. |
|
|
289 | |
|
|
290 | Note that setting the signal to C<SIG_IGN> can have unintended side |
|
|
291 | effects when you fork and exec other programs, as often they do nto expect |
|
|
292 | signals to be ignored by default. |
273 | |
293 | |
274 | =item $async->block |
294 | =item $async->block |
275 | |
295 | |
276 | =item $async->unblock |
296 | =item $async->unblock |
277 | |
297 | |
… | |
… | |
292 | This call C<< $async->block >> and installs a handler that is called when |
312 | This call C<< $async->block >> and installs a handler that is called when |
293 | the current scope is exited (via an exception, by canceling the Coro |
313 | the current scope is exited (via an exception, by canceling the Coro |
294 | thread, by calling last/goto etc.). |
314 | thread, by calling last/goto etc.). |
295 | |
315 | |
296 | This is the recommended (and fastest) way to implement critical sections. |
316 | This is the recommended (and fastest) way to implement critical sections. |
|
|
317 | |
|
|
318 | =item ($block_func, $block_arg) = $async->scope_block_func |
|
|
319 | |
|
|
320 | Returns the address of a function that implements the C<scope_block> |
|
|
321 | functionality. |
|
|
322 | |
|
|
323 | It has the following prototype and needs to be passed the specified |
|
|
324 | C<$block_arg>, which is a C<void *> cast to C<IV>: |
|
|
325 | |
|
|
326 | void (*block_func) (void *block_arg) |
|
|
327 | |
|
|
328 | An example call would look like: |
|
|
329 | |
|
|
330 | block_func (block_arg); |
|
|
331 | |
|
|
332 | The function is safe to call only from within the toplevel of a perl XS |
|
|
333 | function and will call C<LEAVE> and C<ENTER> (in this order!). |
297 | |
334 | |
298 | =item $async->pipe_enable |
335 | =item $async->pipe_enable |
299 | |
336 | |
300 | =item $async->pipe_disable |
337 | =item $async->pipe_disable |
301 | |
338 | |