Updating docs

STEllAR-GROUP · Jul 3, 2017 · af43293 · af43293
1 parent 6c74330
commit af43293
Show file tree

Hide file tree

Showing 574 changed files with 4,313 additions and 4,313 deletions.
diff --git a/docs/html/HPX_DEFINE_COMPONENT_ACTION.html b/docs/html/HPX_DEFINE_COMPONENT_ACTION.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_DEFINE_COMPONENT_ACTION(...)</pre></div>
 <div class="refsect1">
-<a name="idm140178945831136"></a><h2>Description</h2>
+<a name="idm139809610555344"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_DEFINE_COMPONENT_ACTION</em></span> can be used to register a member function of a component as an action type named <span class="emphasis"><em>action_type</em></span>.</p>
 <p>The parameter <span class="emphasis"><em>component</em></span> is the type of the component exposing the member function <span class="emphasis"><em>func</em></span> which should be associated with the newly defined action type. The parameter <code class="computeroutput">action_type</code> is the name of the action type to register with HPX.</p>
 <p><b>Example:&#160;</b></p>

diff --git a/docs/html/HPX_DEFINE_PLAIN_ACTION.html b/docs/html/HPX_DEFINE_PLAIN_ACTION.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_DEFINE_PLAIN_ACTION(...)</pre></div>
 <div class="refsect1">
-<a name="idm140178945771024"></a><h2>Description</h2>
+<a name="idm139809610495392"></a><h2>Description</h2>
 <p><b>Example:&#160;</b></p>
 <p>
 </p>

diff --git a/docs/html/HPX_PLAIN_ACTION.html b/docs/html/HPX_PLAIN_ACTION.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_PLAIN_ACTION(...)</pre></div>
 <div class="refsect1">
-<a name="idm140178945734240"></a><h2>Description</h2>
+<a name="idm139809610458480"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_PLAIN_ACTION</em></span> can be used to define a plain action (e.g. an action encapsulating a global or free function) based on the given function <span class="emphasis"><em>func</em></span>. It defines the action type <span class="emphasis"><em>name</em></span> representing the given function. This macro additionally registers the newly define action type with HPX.</p>
 <p>The parameter <code class="computeroutput">func</code> is a global or free (non-member) function which should be encapsulated into a plain action. The parameter <code class="computeroutput">name</code> is the name of the action type defined by this macro.</p>
 <p><b>Example:&#160;</b></p>

diff --git a/docs/html/HPX_PLAIN_ACTION_ID.html b/docs/html/HPX_PLAIN_ACTION_ID.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_PLAIN_ACTION_ID(func, name, id)</pre></div>
 <div class="refsect1">
-<a name="idm140178945695248"></a><h2>Description</h2>
+<a name="idm139809610419488"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_PLAIN_ACTION_ID</em></span> can be used to define a plain action (e.g. an action encapsulating a global or free function) based on the given function <span class="emphasis"><em>func</em></span>. It defines the action type <span class="emphasis"><em>actionname</em></span> representing the given function. The parameter <span class="emphasis"><em>actionid</em></span> </p>
 <p>The parameter <span class="emphasis"><em>actionid</em></span> specifies an unique integer value which will be used to represent the action during serialization.</p>
 <p>The parameter <code class="computeroutput">func</code> is a global or free (non-member) function which should be encapsulated into a plain action. The parameter <code class="computeroutput">name</code> is the name of the action type defined by this macro.</p>

diff --git a/docs/html/HPX_REGISTER_ACTION.html b/docs/html/HPX_REGISTER_ACTION.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_REGISTER_ACTION(...)</pre></div>
 <div class="refsect1">
-<a name="idm140178945856832"></a><h2>Description</h2>
+<a name="idm139809610581120"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_REGISTER_ACTION</em></span> can be used to define all the boilerplate code which is required for proper functioning of component actions in the context of HPX.</p>
 <p>The parameter <span class="emphasis"><em>action</em></span> is the type of the action to define the boilerplate for.</p>
 <p>This macro can be invoked with an optional second parameter. This parameter specifies a unique name of the action to be used for serialization purposes. The second parameter has to be specified if the first parameter is not usable as a plain (non-qualified) C++ identifier, i.e. the first parameter contains special characters which cannot be part of a C++ identifier, such as '&lt;', '&gt;', or ':'.</p>

diff --git a/docs/html/HPX_REGISTER_ACTION_DECLARATION.html b/docs/html/HPX_REGISTER_ACTION_DECLARATION.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_REGISTER_ACTION_DECLARATION(...)</pre></div>
 <div class="refsect1">
-<a name="idm140178945916336"></a><h2>Description</h2>
+<a name="idm139809610640688"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_REGISTER_ACTION_DECLARATION</em></span> can be used to declare all the boilerplate code which is required for proper functioning of component actions in the context of HPX.</p>
 <p>The parameter <span class="emphasis"><em>action</em></span> is the type of the action to declare the boilerplate for.</p>
 <p>This macro can be invoked with an optional second parameter. This parameter specifies a unique name of the action to be used for serialization purposes. The second parameter has to be specified if the first parameter is not usable as a plain (non-qualified) C++ identifier, i.e. the first parameter contains special characters which cannot be part of a C++ identifier, such as '&lt;', '&gt;', or ':'.</p>

diff --git a/docs/html/HPX_REGISTER_ACTION_ID.html b/docs/html/HPX_REGISTER_ACTION_ID.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_REGISTER_ACTION_ID(action, actionname, actionid)</pre></div>
 <div class="refsect1">
-<a name="idm140178945846272"></a><h2>Description</h2>
+<a name="idm139809610570560"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_REGISTER_ACTION</em></span> can be used to define all the boilerplate code which is required for proper functioning of component actions in the context of HPX.</p>
 <p>The parameter <span class="emphasis"><em>action</em></span> is the type of the action to define the boilerplate for.</p>
 <p>The parameter <span class="emphasis"><em>actionname</em></span> specifies an unique name of the action to be used for serialization purposes. The second parameter has to be usable as a plain (non-qualified) C++ identifier, it should not contain special characters which cannot be part of a C++ identifier, such as '&lt;', '&gt;', or ':'.</p>

diff --git a/docs/html/HPX_REGISTER_COMPONENT.html b/docs/html/HPX_REGISTER_COMPONENT.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_REGISTER_COMPONENT(type, name, mode)</pre></div>
 <div class="refsect1">
-<a name="idm140178944527456"></a><h2>Description</h2>
+<a name="idm139809609251696"></a><h2>Description</h2>
 <p>This macro is used create and to register a minimal component factory for a component type which allows it to be remotely created using the <span class="emphasis"><em>hpx::new_&lt;&gt;</em></span> function.</p>
 <p>This macro can be invoked with one, two or three arguments</p>
 <p>

diff --git a/docs/html/HPX_THROWS_IF.html b/docs/html/HPX_THROWS_IF.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_THROWS_IF(ec, errcode, f, msg)</pre></div>
 <div class="refsect1">
-<a name="idm140178939562576"></a><h2>Description</h2>
+<a name="idm139809604287776"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_THROWS_IF</em></span> can be used to either throw a <span class="emphasis"><em><a class="link" href="hpx/exception.html" title="Class exception">hpx::exception</a></em></span> or to initialize a <span class="emphasis"><em><a class="link" href="hpx/error_code.html" title="Class error_code">hpx::error_code</a></em></span> from the given parameters. If &amp;ec == &amp;hpx::throws, the semantics of this macro are equivalent to <span class="emphasis"><em>HPX_THROW_EXCEPTION</em></span>. If &amp;ec != &amp;hpx::throws, the <span class="emphasis"><em><a class="link" href="hpx/error_code.html" title="Class error_code">hpx::error_code</a></em></span> instance <code class="computeroutput">ec</code> is initialized instead.</p>
 <p>The parameter <code class="computeroutput">errcode</code> holds the hpx::error code from which the new exception should be initialized. The parameter <code class="computeroutput">f</code> is expected to hold the name of the function exception is thrown from and the parameter <code class="computeroutput">msg</code> holds the error message the new exception should encapsulate. </p>
 </div>

diff --git a/docs/html/HPX_THROW_EXCEPTION.html b/docs/html/HPX_THROW_EXCEPTION.html
@@ -26,7 +26,7 @@ <h2 xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" class="re
 
 </span>HPX_THROW_EXCEPTION(errcode, f, msg)</pre></div>
 <div class="refsect1">
-<a name="idm140178939592480"></a><h2>Description</h2>
+<a name="idm139809604317680"></a><h2>Description</h2>
 <p>The macro <span class="emphasis"><em>HPX_THROW_EXCEPTION</em></span> can be used to throw a <a class="link" href="hpx/exception.html" title="Class exception">hpx::exception</a>. The purpose of this macro is to prepend the source file name and line number of the position where the exception is thrown to the error message. Moreover, this associates additional diagnostic information with the exception, such as file name and line number, locality id and thread id, and stack backtrace from the point where the exception was thrown.</p>
 <p>The parameter <code class="computeroutput">errcode</code> holds the hpx::error code the new exception should encapsulate. The parameter <code class="computeroutput">f</code> is expected to hold the name of the function exception is thrown from and the parameter <code class="computeroutput">msg</code> holds the error message the new exception should encapsulate.</p>
 <p><b>Example:&#160;</b></p>

diff --git a/docs/html/code/hpx/parallel/executors/execution_fwd.hpp b/docs/html/code/hpx/parallel/executors/execution_fwd.hpp
@@ -49,9 +49,9 @@ namespace hpx { namespace parallel { namespace execution
         struct sync_execute_tag {};
         struct async_execute_tag {};
         struct then_execute_tag {};
-        struct sync_bulk_execute_tag {};
-        struct async_bulk_execute_tag {};
-        struct then_bulk_execute_tag {};
+        struct bulk_sync_execute_tag {};
+        struct bulk_async_execute_tag {};
+        struct bulk_then_execute_tag {};
 
         template <typename Executor, typename ... Ts>
         struct undefined_customization_point;
@@ -103,7 +103,7 @@ namespace hpx { namespace parallel { namespace execution
         };
 
         template <>
-        struct customization_point<sync_bulk_execute_tag>
+        struct customization_point<bulk_sync_execute_tag>
         {
             template <typename Executor, typename F, typename Shape,
                 typename ... Ts>
@@ -113,7 +113,7 @@ namespace hpx { namespace parallel { namespace execution
         };
 
         template <>
-        struct customization_point<async_bulk_execute_tag>
+        struct customization_point<bulk_async_execute_tag>
         {
             template <typename Executor, typename F, typename Shape,
                 typename ... Ts>
@@ -123,7 +123,7 @@ namespace hpx { namespace parallel { namespace execution
         };
 
         template <>
-        struct customization_point<then_bulk_execute_tag>
+        struct customization_point<bulk_then_execute_tag>
         {
             template <typename Executor, typename F, typename Shape,
                 typename Future, typename ... Ts>
@@ -246,7 +246,7 @@ namespace hpx { namespace parallel { namespace execution
         /// \param ts   [in] Additional arguments to use to invoke \a f.
         ///
         /// \note This is valid for two way executors (calls
-        ///       exec.apply_execute(f, ts...), if available, otherwise
+        ///       exec.post(f, ts...), if available, otherwise
         ///       it calls exec.async_execute(f, ts...) while discarding the
         ///       returned future), and for non-blocking two way executors
         ///       (calls exec.post(f, ts...) if it exists).
@@ -258,13 +258,13 @@ namespace hpx { namespace parallel { namespace execution
 
         ///////////////////////////////////////////////////////////////////////
         // BulkTwoWayExecutor customization points:
-        // execution::async_bulk_execute, execution::sync_bulk_execute,
-        // execution::then_bulk_execute
+        // execution::bulk_async_execute, execution::bulk_sync_execute,
+        // execution::bulk_then_execute
 
         /// Bulk form of synchronous execution agent creation.
         ///
         /// \note This is deliberately different from the bulk_sync_execute
-        ///       customization points specified in P0443.The sync_bulk_execute
+        ///       customization points specified in P0443.The bulk_sync_execute
         ///       customization point defined here is more generic and is used
         ///       as the workhorse for implementing the specified APIs.
         ///
@@ -286,24 +286,24 @@ namespace hpx { namespace parallel { namespace execution
         ///              boundaries for the arguments to be passed to \a f.
         /// \param ts    [in] Additional arguments to use to invoke \a f.
         ///
-        /// \returns The return type of \a executor_type::sync_bulk_execute
+        /// \returns The return type of \a executor_type::bulk_sync_execute
         ///          if defined by \a executor_type. Otherwise a vector holding
         ///          the returned values of each invocation of \a f except when
         ///          \a f returns void, which case void is returned.
         ///
-        /// \note This calls exec.sync_bulk_execute(f, shape, ts...) if it
+        /// \note This calls exec.bulk_sync_execute(f, shape, ts...) if it
         ///       exists; otherwise it executes sync_execute(f, shape, ts...)
         ///       as often as needed.
         ///
-        constexpr detail::customization_point<detail::sync_bulk_execute_tag> const&
-            sync_bulk_execute = detail::static_const<
-                    detail::customization_point<detail::sync_bulk_execute_tag>
+        constexpr detail::customization_point<detail::bulk_sync_execute_tag> const&
+            bulk_sync_execute = detail::static_const<
+                    detail::customization_point<detail::bulk_sync_execute_tag>
                 >::value;
 
         /// Bulk form of asynchronous execution agent creation.
         ///
         /// \note This is deliberately different from the bulk_async_execute
-        ///       customization points specified in P0443.The async_bulk_execute
+        ///       customization points specified in P0443.The bulk_async_execute
         ///       customization point defined here is more generic and is used
         ///       as the workhorse for implementing the specified APIs.
         ///
@@ -324,24 +324,24 @@ namespace hpx { namespace parallel { namespace execution
         ///              boundaries for the arguments to be passed to \a f.
         /// \param ts    [in] Additional arguments to use to invoke \a f.
         ///
-        /// \returns The return type of \a executor_type::async_bulk_execute if
+        /// \returns The return type of \a executor_type::bulk_async_execute if
         ///          defined by \a executor_type. Otherwise a vector
         ///          of futures holding the returned values of each invocation
         ///          of \a f.
         ///
-        /// \note This calls exec.async_bulk_execute(f, shape, ts...) if it
+        /// \note This calls exec.bulk_async_execute(f, shape, ts...) if it
         ///       exists; otherwise it executes async_execute(f, shape, ts...)
         ///       as often as needed.
         ///
-        constexpr detail::customization_point<detail::async_bulk_execute_tag> const&
-            async_bulk_execute = detail::static_const<
-                    detail::customization_point<detail::async_bulk_execute_tag>
+        constexpr detail::customization_point<detail::bulk_async_execute_tag> const&
+            bulk_async_execute = detail::static_const<
+                    detail::customization_point<detail::bulk_async_execute_tag>
                 >::value;
 
         /// Bulk form of execution agent creation depending on a given future.
         ///
         /// \note This is deliberately different from the then_sync_execute
-        ///       customization points specified in P0443.The then_bulk_execute
+        ///       customization points specified in P0443.The bulk_then_execute
         ///       customization point defined here is more generic and is used
         ///       as the workhorse for implementing the specified APIs.
         ///
@@ -364,20 +364,20 @@ namespace hpx { namespace parallel { namespace execution
         ///             given function depends on.
         /// \param ts    [in] Additional arguments to use to invoke \a f.
         ///
-        /// \returns The return type of \a executor_type::then_bulk_execute
+        /// \returns The return type of \a executor_type::bulk_then_execute
         ///          if defined by \a executor_type. Otherwise a vector holding
         ///          the returned values of each invocation of \a f.
         ///
-        /// \note This calls exec.then_bulk_execute(f, shape, pred, ts...) if it
+        /// \note This calls exec.bulk_then_execute(f, shape, pred, ts...) if it
         ///       exists; otherwise it executes
         ///       sync_execute(f, shape, pred.share(), ts...) (if this executor
         ///       is also an OneWayExecutor), or
         ///       async_execute(f, shape, pred.share(), ts...) (if this executor
         ///       is also a TwoWayExecutor) - as often as needed.
         ///
-        constexpr detail::customization_point<detail::then_bulk_execute_tag> const&
-            then_bulk_execute = detail::static_const<
-                    detail::customization_point<detail::then_bulk_execute_tag>
+        constexpr detail::customization_point<detail::bulk_then_execute_tag> const&
+            bulk_then_execute = detail::static_const<
+                    detail::customization_point<detail::bulk_then_execute_tag>
                 >::value;
     }
 }}}

diff --git a/docs/html/code/hpx/parallel/executors/parallel_executor.hpp b/docs/html/code/hpx/parallel/executors/parallel_executor.hpp
@@ -91,7 +91,7 @@ namespace hpx { namespace parallel { namespace execution
 
         // NonBlockingOneWayExecutor (adapted) interface
         template <typename F, typename ... Ts>
-        static void apply_execute(F && f, Ts &&... ts)
+        static void post(F && f, Ts &&... ts)
         {
             hpx::apply(std::forward<F>(f), std::forward<Ts>(ts)...);
         }
@@ -101,7 +101,7 @@ namespace hpx { namespace parallel { namespace execution
         std::vector<hpx::future<
             typename detail::bulk_function_result<F, S, Ts...>::type
         > >
-        async_bulk_execute(F && f, S const& shape, Ts &&... ts) const
+        bulk_async_execute(F && f, S const& shape, Ts &&... ts) const
         {
             // lazily initialize once
             static std::size_t global_num_tasks =
@@ -248,7 +248,7 @@ namespace hpx { namespace parallel { inline namespace v3
         bulk_async_execute(F && f, S const& shape, Ts &&... ts)
         {
             using base_type = parallel::execution::parallel_executor;
-            return base_type::async_bulk_execute(std::forward<F>(f), shape,
+            return base_type::bulk_async_execute(std::forward<F>(f), shape,
                 std::forward<Ts>(ts)...);
         }
     };