| globus_callback_spaces(3) | globus_common | globus_callback_spaces(3) |
globus_callback_spaces - Globus Callback Spaces
- Globus Callback Spaces.
enum globus_callback_space_behavior_t {
GLOBUS_CALLBACK_SPACE_BEHAVIOR_SINGLE,
GLOBUS_CALLBACK_SPACE_BEHAVIOR_SERIALIZED,
GLOBUS_CALLBACK_SPACE_BEHAVIOR_THREADED }
Callback space behaviors describe how a space behaves. globus_result_t
globus_callback_space_init (globus_callback_space_t *space,
globus_callback_space_attr_t attr)
Initialize a user space. globus_result_t
globus_callback_space_reference (globus_callback_space_t
space)
Take a reference to a space. globus_result_t
globus_callback_space_destroy (globus_callback_space_t space)
Destroy a reference to a user space. globus_result_t
globus_callback_space_attr_init (globus_callback_space_attr_t
*attr)
Initialize a space attr. globus_result_t
globus_callback_space_attr_destroy
(globus_callback_space_attr_t attr)
Destroy a space attr. globus_result_t
globus_callback_space_attr_set_behavior
(globus_callback_space_attr_t attr,
globus_callback_space_behavior_t behavior)
Set the behavior of a space. globus_result_t
globus_callback_space_attr_get_behavior
(globus_callback_space_attr_t attr,
globus_callback_space_behavior_t *behavior)
Get the behavior associated with an attr. globus_result_t
globus_callback_space_get (globus_callback_space_t *space)
Retrieve the space of a currently running callback. int
globus_callback_space_get_depth (globus_callback_space_t
space)
Retrieve the current nesting level of a space. globus_bool_t
globus_callback_space_is_single (globus_callback_space_t
space)
See if the specified space is a single threaded behavior space.
globus_bool_t globus_callback_get_timeout (globus_reltime_t
*time_left)
Get the amount of time left in a callback. globus_bool_t
globus_callback_has_time_expired ()
See if there is remaining time in a callback. globus_bool_t
globus_callback_was_restarted ()
See if a callback has been restarted. globus_result_t
globus_callback_space_register_signal_handler (int signum,
globus_bool_t persist, globus_callback_func_t callback_func,
void *callback_user_arg, globus_callback_space_t space)
Fire a callback when the specified signal is received. globus_result_t
globus_callback_unregister_signal_handler (int signum,
globus_callback_func_t unregister_callback, void *unreg_arg)
Unregister a signal handling callback. void
globus_callback_add_wakeup_handler (void(*wakeup)(void *), void
*user_arg)
Register a wakeup handler with callback library. #define
GLOBUS_CALLBACK_GLOBAL_SPACE
Global callback space. #define GLOBUS_SIGNAL_INTERRUPT
Globus Callback Spaces.
Global callback space. The 'global' space handle.
This is the default space handle implied if no spaces are explicitly created.
Use this to trap interrupts (SIGINT on unix). In the future, this will also map to handle ctrl-C on win32.
Callback space behaviors describe how a space behaves. In a non-threaded build all spaces exhibit a behavior == _BEHAVIOR_SINGLE. Setting a specific behavior in this case is ignored.
In a threaded build, _BEHAVIOR_SINGLE retains all the rules and behaviors of a non-threaded build while _BEHAVIOR_THREADED makes the space act as the global space.
Setting a space's behavior to _BEHAVIOR_SINGLE guarantees that the poll protection will always be there and all callbacks are serialized and only kicked out when polled for. In a threaded build, it is still necessary to poll for callbacks in a _BEHAVIOR_SINGLE space. (globus_cond_wait() will take care of this for you also)
Setting a space's behavior to _BEHAVIOR_SERIALIZED guarantees that the poll protection will always be there and all callbacks are serialized. In a threaded build, it is NOT necessary to poll for callbacks in a _BEHAVIOR_SERIALIZED space. Callbacks in this space will be delivered as soon as possible, but only one outstanding (and unblocked) callback will be allowed at any time.
Setting a space's behavior to _BEHAVIOR_THREADED allows the user to have the poll protection provided by spaces when built non-threaded, yet, be fully threaded when built threaded (where poll protection is not needed)
Enumerator
Register a wakeup handler with callback library. This is really only needed in non-threaded builds, but for cross builds should be used everywhere that a callback may sleep for an extended period of time.
An example use is for an io poller that sleeps indefinitely on select(). If the callback library receives a signal that it needs to deliver asap, it will call the wakeup handler(s), These wakeup handlers must run as though they were called from a signal handler (don't use any thread utilities). The io poll example will likely write a single byte to a pipe that select() is monitoring.
This handler will not be unregistered until the callback library is deactivated (via common).
Parameters
Get the amount of time left in a callback. This function retrieves the remaining time a callback is allowed to run. If a callback has already timed out, time_left will be set to zero and GLOBUS_TRUE returned. This function is intended to be called within a callback's stack, but is harmless to call anywhere (will return GLOBUS_FALSE and an infinite time_left)
Parameters
Returns
See if there is remaining time in a callback. This function returns GLOBUS_TRUE if the running time of a callback has already expired. This function is intended to be called within a callback's stack, but is harmless to call anywhere (will return GLOBUS_FALSE)
Returns
Destroy a space attr.
Parameters
Returns
See also
Get the behavior associated with an attr. Note: for a non-threaded build, this will always pass back a behavior == GLOBUS_CALLBACK_SPACE_BEHAVIOR_SINGLE.
Parameters
Returns
Initialize a space attr. Currently, the only attr to set is the behavior. The default behavior associated with this attr is GLOBUS_CALLBACK_SPACE_BEHAVIOR_SINGLE
Parameters
Returns
Set the behavior of a space.
Parameters
Returns
See also
Destroy a reference to a user space. This will destroy a reference to a previously initialized space. Space will not actually be destroyed until all callbacks registered with this space have been run and unregistered (if the user has a handle to that callback) AND all references (from globus_callback_space_reference()) have been destroyed.
Parameters
Returns
See also
globus_callback_space_reference()
Retrieve the space of a currently running callback.
Parameters
Returns
Retrieve the current nesting level of a space.
Parameters
Returns
Initialize a user space. This creates a user space.
Parameters
Returns
See also
globus_io_attr_set_callback_space()
See if the specified space is a single threaded behavior space.
Parameters
Returns
Take a reference to a space. A library which has been 'given' a space to provide callbacks on would use this to take a reference on the user's space. This prevents mayhem should a user destroy a space before the library is done with it. This reference should be destroyed with globus_callback_space_destroy() (think dup())
Parameters
Returns
Fire a callback when the specified signal is received. Note that there is a tiny delay between the time this call returns and the signal is actually handled by this library. It is likely that, if the signal was received the instant the call returned, it will be lost (this is normally not an issue, since you would call this in your startup code anyway)
Parameters
Returns
Unregister a signal handling callback.
Parameters
Returns
See if a callback has been restarted. If the callback is a oneshot, this merely means the callback called globus_thread_blocking_space_will_block (or globus_cond_wait() at some point.
For a periodic, it signifies the same and also that the periodic has been requeued. This means that the callback function may be reentered if the period is short enough (on a threaded build)
Returns
Generated automatically by Doxygen for globus_common from the source code.
| Sun Dec 13 2020 | Version 18.9 |