fiber/libs/task/doc/task.qbk

[/
          Copyright Oliver Kowalke 2009.
 Distributed under the Boost Software License, Version 1.0.
    (See accompanying file LICENSE_1_0.txt or copy at
          http://www.boost.org/LICENSE_1_0.txt
]

[article Task
    [quickbook 1.4]
    [authors [Kowalke, Oliver]]
    [copyright 2009 Oliver Kowalke]
    [purpose C++ Library for asynchronous execution of tasks]
    [category text]
    [license
        Distributed under the Boost Software License, Version 1.0.
        (See accompanying file LICENSE_1_0.txt or copy at
        [@http://www.boost.org/LICENSE_1_0.txt])
    ]
]


[def __boost_atomic__ [@http://www.chaoticmind.net/~hcb/projects/boost.atomic [*Boost.Atomic]]]
[def __boost_tasklet__ [@http://http://www.boostpro.com/vault/index.php?&direction=0&order=&directory=Concurrent%20Programming [*Boost.Tasklet]]]
[def __boost_move__ [@http://svn.boost.org/svn/boost/sandbox/move [*Boost.Move]]]
[def __boost_task__ [*Boost.Task]]
[def __boost_thread__ [@http://www.boost.org/libs/thread [*Boost.Thread]]]

[template link_act[link_text] [link task.async_execution.async_completion_token [link_text]]]
[template link_as_subtask[link_text] [link task.async_execution.execution_policy.as_subtask [link_text]]]
[template link_async[link_text] [link task.async_execution.async [link_text]]]
[template link_ep[link_text] [link task.async_execution.execution_policy [link_text]]]
[template link_forkjoin[link_text] [link task.async_execution.execution_policy.threadpool.forkjoin [link_text]]]
[template link_handle[link_text] [link task.async_execution.async_completion_token.handle [link_text]]]
[template link_new_thread[link_text] [link task.async_execution.execution_policy.new_thread [link_text]]]
[template link_own_thread[link_text] [link task.async_execution.execution_policy.own_thread [link_text]]]
[template link_queue[link_text] [link task.async_execution.execution_policy.threadpool.queue [link_text]]]
[template link_task[link_text] [link task.task_management.task [link_text]]]
[template link_threadpool[link_text] [link task.async_execution.execution_policy.threadpool [link_text]]]
[template link_work_stealing[link_text] [link task.async_execution.execution_policy.threadpool.workstealing [link_text]]]

[def __hardware_concurrency__ `boost::thread::hardware_concurrency()`]

[def __as_sub_task__ `boost::tasks::as_sub_task`]
[def __attribute_type__ `boost::tasks::attribute_type`]
[def __bounded_queue__ `boost::tasks::bounded_queue`]
[def __dynamic_pool__ `boost::tasks::dynamic_pool`]
[def __has_attribute__ `boost::tasks::has_attribute`]
[def __hwm__ `boost::tasks::high_watermark`]
[def __lwm__ `boost::tasks::low_watermark`]
[def __pool_size__ `boost::tasks::poolsize`]
[def __priority__ `boost::tasks::priority`]
[def __replace_oldest__ `boost::tasks::replace_oldest`]
[def __static_pool__ `boost::tasks::static_pool`]
[def __system_time__ `boost::tasks::system_time`]
[def __take_oldest__ `boost::tasks::take_oldest`]
[def __task_interrupted__ `boost::tasks::task_interrupted`]
[def __unbounded_queue__ `boost::tasks::unbounded_queue`]

[def __make_task__ `boost::tasks::make_task()`]
[def __waitfor_all__ `boost::tasks::waitfor_all()`]

[def __fn_tt_interrupt__ `boost::this_task::interrupt()`]
[def __fn_interruption_requested__ `boost::this_thread::interruption_requested()`]
[def __fn_make_task__ `boost::tasks::make_task()`]
[def __fn_runs_in_pool__ `boost::this_task::runs_in_pool()`]
[def __fn_worker_id__ `boost::this_task::worker_id()`]
[def __fn_yield__ `boost::this_task::yield()`]

[def __fn_async__ `boost::tasks::async()`]
[def __fn_make_task__ `boost::tasks::make_task()`]

[def __fn_bind_to_processors__ `bind_to_processors()`]
[def __fn_closed__ `close()`]
[def __fn_get__ `get()`]
[def __fn_has_value__ `has_value()`]
[def __fn_has_exception__ `has_exception()`]
[def __fn_interrupt__ `interrupt()`]
[def __fn_interrupt_and_wait__ `interrupt_and_wait()`]
[def __fn_interrupt_and_wait_for__ `interrupt_and_wait_for()`]
[def __fn_interrupt_and_wait_until__ `interrupt_and_wait_until()`]
[def __fn_interruption_requested__ `interruption_requested()`]
[def __fn_is_ready__ `is_ready()`]
[def __fn_operator__ `operator()()`]
[def __fn_size__ `size()`]
[def __fn_shutdown__ `shutdown()`]
[def __fn_shutdown_now__ `shutdown_now()`]
[def __fn_wait__ `wait()`]
[def __fn_wait_for__ `wait_for()`]
[def __fn_wait_until__ `wait_until()`]


[def __act__ [link_act ['asynchronous-completion-token]]]
[def __async__ [link_async ['async()]]]
[def __ep__ [link_ep ['execution-policy]]]
[def __eps__ [link_ep ['execution-policies]]]
[def __blocked__ ['blocked]]
[def __callable__ ['callable]]
[def __coop_task__ ['cooperative task]]
[def __duration__ ['Duration]]
[def __fork_join__ [link_forkjoin ['fork/join]]]
[def __handle__ [link_handle ['handle]]]
[def __interruption_point__ ['interruption-point]]
[def __interruption_points__ ['interruption-points]]
[def __new_thread__ [link_new_thread ['new_thread]]]
[def __own_thread__ [link_own_thread ['own_thread]]]
[def __queue__ [link_queue ['queue]]]
[def __task__ [link_task ['task]]]
[def __thread_pool__ [link_threadpool ['thread-pool]]]
[def __thread_pools__ [link_threadpool ['thread-pools]]]
[def __sub_task__ ['sub-task]]
[def __sub_tasks__ ['sub-tasks]]
[def __work_item__ ['work-item]]
[def __work_items__ ['work-items]]
[def __work_stealing__ [link_work_stealing ['work-stealing]]]
[def __worker_queue__ ['worker-queue]]
[def __worker_thread__ ['worker-thread]]
[def __worker_threads__ ['worker-threads]]



[include overview.qbk]
[include task_ref.qbk]
[include async_execution.qbk]
[include spin_synchronization.qbk]
[include todo.qbk]
[include acknowledgements.qbk]