Topic: Questions About WG21 Paper P0443R5 - A Unified
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Sat, 31 Mar 2018 22:51:42 -0700 (PDT)
Raw View
------=_Part_232_740322750.1522561902039
Content-Type: multipart/alternative;
boundary="----=_Part_233_54084992.1522561902040"
------=_Part_233_54084992.1522561902040
Content-Type: text/plain; charset="UTF-8"
I think the facilities included in the proposal are very useful in
concurrent programming. However, I am confused about the following issues:
1. What is the motivation of `executor_shape` and `executor_index`? I think
it might be more reasonable to replace them with `size_t`.
2. In the "BulkOneWayExecutor requirements", the expression
`x.bulk_execute(f, n, sf)` shall be well-formed with sepcific semantics:
> Invokes sf() on an unspecified execution agent to produce the value s.
> Creates a group of execution agents of shape n which invokes DECAY_COPY(
> std::forward<F>(f))(i, s) at most once for each value of i in the range
> [0,n), with the call to DECAY_COPY being evaluated in the thread that
> called bulk_execute.
>
I think it could be too complex to use. Maybe we should consider replacing
it with a more easy-to-use one, for example:
template <class... Fs>
void bulk_execute(Fs&&...);
Every type in `Fs...` could either be a functor or a container of functors.
3. I think there is little necessity to provide "polymorphic executors".
One could easily make an executor polymorphic with the PFA (P0957R0).
4. The `static_thread_pool` seems too "simple", and there are a lot more
cases require more flexible configurations of a thread pool other than an
initial thread count, e.g., bounded queue, keep-alive duration, threads
with priorities, fibers, timing, etc.
I am looking forward to your comments!
Mingxin Wang
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/077cfbc3-5d28-4881-bf3d-56e9a644d20a%40isocpp.org.
------=_Part_233_54084992.1522561902040
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">I think the facilities included in the proposal are very u=
seful in concurrent programming. However, I am confused about the following=
issues:<div><br></div><div>1. What is the motivation of `executor_shape` a=
nd `executor_index`? I think it might be more reasonable to replace them wi=
th `size_t`.</div><div>2. In the "BulkOneWayExecutor requirements"=
;, the expression `x.bulk_execute(f, n, sf)` shall be well-formed with sepc=
ific semantics:</div><blockquote class=3D"gmail_quote" style=3D"margin: 0px=
0px 0px 0.8ex; border-left: 1px solid rgb(204, 204, 204); padding-left: 1e=
x;">Invokes sf() on an unspecified execution agent to produce the value s. =
Creates a group of execution agents of shape n which invokes DECAY_COPY( st=
d::forward<F>(f))(i, s) at most once for each value of i in the range=
[0,n), with the call to DECAY_COPY being evaluated in the thread that call=
ed bulk_execute.=C2=A0<br></blockquote><div>I think it could be too complex=
to use. Maybe we should consider replacing it with a more=C2=A0easy-to-use=
one, for example:</div><div><div class=3D"prettyprint" style=3D"background=
-color: rgb(250, 250, 250); border-color: rgb(187, 187, 187); border-style:=
solid; border-width: 1px; word-wrap: break-word;"><code class=3D"prettypri=
nt"><div class=3D"subprettyprint"><div class=3D"subprettyprint">template &l=
t;class... Fs></div><div class=3D"subprettyprint">void bulk_execute(Fs&a=
mp;&...);</div></div></code></div>Every type in `Fs...` could either be=
a functor or a container of functors.</div><div>3. I think there is little=
necessity to provide "polymorphic executors". One could easily m=
ake an executor polymorphic with the PFA (P0957R0).</div><div>4. The `stati=
c_thread_pool` seems too "simple", and there are a lot more cases=
require more flexible configurations of a thread pool other than an initia=
l thread count, e.g., bounded queue, keep-alive duration, threads with prio=
rities, fibers, timing, etc.<br><br></div><div><div>I am looking forward to=
your comments!</div><div><br></div><div>Mingxin Wang</div></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/077cfbc3-5d28-4881-bf3d-56e9a644d20a%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/077cfbc3-5d28-4881-bf3d-56e9a644d20a=
%40isocpp.org</a>.<br />
------=_Part_233_54084992.1522561902040--
------=_Part_232_740322750.1522561902039--
.
Author: Lee Howes <xrikcus@gmail.com>
Date: Sun, 1 Apr 2018 17:39:57 -0700
Raw View
--0000000000004e5c4b0568d2d4fa
Content-Type: text/plain; charset="UTF-8"
1) Multi-dimensional iteration spaces are optimal to generate iteration
variables on some platforms. In general, it is cheaper to flatten an
N-dimensional space than to wrap a one-dimensional one.
2) A collection of functors would be an unnecessary pessimisation. We don't
write for loops by generating a vector of functors, why would that be
better here? The bulk execution requirements are a little confusing at
first, but I think a couple of examples cure that. Most use cases will be
covered by the parallel algorithms, so few developers will need to interact
with the complexity.
3) Polymorphic executors are specified to correctly deal with require and
prefer specifications of underlying executors. They need to behave
correctly under those circumstances, which would mean building on top of
any general polymorphism interface.
4) Yes, it is minimal. The goal was never to specify a fully usable thread
pool - only that some minimal structure be provided such that minimal
executors can be defined. Trying to specify a perfect thread pool, assuming
one to exist, would delay the executors specification for no gain.
On 31 March 2018 at 22:51, Mingxin Wang <wmx16835vv@163.com> wrote:
> I think the facilities included in the proposal are very useful in
> concurrent programming. However, I am confused about the following issues:
>
> 1. What is the motivation of `executor_shape` and `executor_index`? I
> think it might be more reasonable to replace them with `size_t`.
> 2. In the "BulkOneWayExecutor requirements", the expression
> `x.bulk_execute(f, n, sf)` shall be well-formed with sepcific semantics:
>
>> Invokes sf() on an unspecified execution agent to produce the value s.
>> Creates a group of execution agents of shape n which invokes DECAY_COPY(
>> std::forward<F>(f))(i, s) at most once for each value of i in the range
>> [0,n), with the call to DECAY_COPY being evaluated in the thread that
>> called bulk_execute.
>>
> I think it could be too complex to use. Maybe we should consider replacing
> it with a more easy-to-use one, for example:
> template <class... Fs>
> void bulk_execute(Fs&&...);
> Every type in `Fs...` could either be a functor or a container of functors.
> 3. I think there is little necessity to provide "polymorphic executors".
> One could easily make an executor polymorphic with the PFA (P0957R0).
> 4. The `static_thread_pool` seems too "simple", and there are a lot more
> cases require more flexible configurations of a thread pool other than an
> initial thread count, e.g., bounded queue, keep-alive duration, threads
> with priorities, fibers, timing, etc.
>
> I am looking forward to your comments!
>
> Mingxin Wang
>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/077cfbc3-5d28-4881-
> bf3d-56e9a644d20a%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/077cfbc3-5d28-4881-bf3d-56e9a644d20a%40isocpp.org?utm_medium=email&utm_source=footer>
> .
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNVRCG993he6dS3Nhk3dkbbSxhW7CED-HHjdm6z2vL5O9Q%40mail.gmail.com.
--0000000000004e5c4b0568d2d4fa
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">1) Multi-dimensional iteration spaces are optimal to gener=
ate iteration variables on some platforms. In general, it is cheaper to fla=
tten an N-dimensional space than to wrap a one-dimensional one.<div>2) A co=
llection of functors would be an unnecessary pessimisation. We don't wr=
ite for loops by generating a vector of functors, why would that be better =
here? The bulk execution requirements are a little confusing at first, but =
I think a couple of examples cure that. Most use cases will be covered by t=
he parallel algorithms, so few developers will need to interact with the co=
mplexity.</div><div>3) Polymorphic executors are specified to correctly dea=
l with require and prefer specifications of underlying executors. They need=
to behave correctly under those circumstances, which would mean building o=
n top of any general polymorphism interface.</div><div>4) Yes, it is minima=
l. The goal was never to specify a fully usable thread pool - only that som=
e minimal structure be provided such that minimal executors can be defined.=
Trying to specify a perfect thread pool, assuming one to exist, would dela=
y the executors specification for no gain. =C2=A0</div></div><div class=3D"=
gmail_extra"><br><div class=3D"gmail_quote">On 31 March 2018 at 22:51, Ming=
xin Wang <span dir=3D"ltr"><<a href=3D"mailto:wmx16835vv@163.com" target=
=3D"_blank">wmx16835vv@163.com</a>></span> wrote:<br><blockquote class=
=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padd=
ing-left:1ex"><div dir=3D"ltr">I think the facilities included in the propo=
sal are very useful in concurrent programming. However, I am confused about=
the following issues:<div><br></div><div>1. What is the motivation of `exe=
cutor_shape` and `executor_index`? I think it might be more reasonable to r=
eplace them with `size_t`.</div><div>2. In the "BulkOneWayExecutor req=
uirements", the expression `x.bulk_execute(f, n, sf)` shall be well-fo=
rmed with sepcific semantics:</div><blockquote class=3D"gmail_quote" style=
=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding=
-left:1ex">Invokes sf() on an unspecified execution agent to produce the va=
lue s. Creates a group of execution agents of shape n which invokes DECAY_C=
OPY( std::forward<F>(f))(i, s) at most once for each value of i in th=
e range [0,n), with the call to DECAY_COPY being evaluated in the thread th=
at called bulk_execute.=C2=A0<br></blockquote><div>I think it could be too =
complex to use. Maybe we should consider replacing it with a more=C2=A0easy=
-to-use one, for example:</div><div><div class=3D"m_1007552365873825802pret=
typrint" style=3D"background-color:rgb(250,250,250);border-color:rgb(187,18=
7,187);border-style:solid;border-width:1px;word-wrap:break-word"><code clas=
s=3D"m_1007552365873825802prettyprint"><div class=3D"m_1007552365873825802s=
ubprettyprint"><div class=3D"m_1007552365873825802subprettyprint">template =
<class... Fs></div><div class=3D"m_1007552365873825802subprettyprint"=
>void bulk_execute(Fs&&...);</div></div></code></div>Every type in =
`Fs...` could either be a functor or a container of functors.</div><div>3. =
I think there is little necessity to provide "polymorphic executors&qu=
ot;. One could easily make an executor polymorphic with the PFA (P0957R0).<=
/div><div>4. The `static_thread_pool` seems too "simple", and the=
re are a lot more cases require more flexible configurations of a thread po=
ol other than an initial thread count, e.g., bounded queue, keep-alive dura=
tion, threads with priorities, fibers, timing, etc.<br><br></div><div><div>=
I am looking forward to your comments!</div><span class=3D"HOEnZb"><font co=
lor=3D"#888888"><div><br></div><div>Mingxin Wang</div></font></span></div><=
/div><span class=3D"HOEnZb"><font color=3D"#888888">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/077cfbc3-5d28-4881-bf3d-56e9a644d20a%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/077c=
fbc3-5d28-4881-<wbr>bf3d-56e9a644d20a%40isocpp.org</a><wbr>.<br>
</font></span></blockquote></div><br></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAJH_FNVRCG993he6dS3Nhk3dkbbSxhW7CED-=
HHjdm6z2vL5O9Q%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">htt=
ps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNVRCG993he6=
dS3Nhk3dkbbSxhW7CED-HHjdm6z2vL5O9Q%40mail.gmail.com</a>.<br />
--0000000000004e5c4b0568d2d4fa--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Sun, 1 Apr 2018 21:51:56 -0700 (PDT)
Raw View
------=_Part_15295_866340481.1522644716120
Content-Type: multipart/alternative;
boundary="----=_Part_15296_1663277179.1522644716121"
------=_Part_15296_1663277179.1522644716121
Content-Type: text/plain; charset="UTF-8"
On Monday, April 2, 2018 at 8:40:00 AM UTC+8, Lee Howes wrote:
>
> 1) Multi-dimensional iteration spaces are optimal to generate iteration
> variables on some platforms. In general, it is cheaper to flatten an
> N-dimensional space than to wrap a one-dimensional one.
>
Why do we need multi-dimensional iteration? Could you provide a meaningful
use case where it would help in performance?
> 2) A collection of functors would be an unnecessary pessimisation. We
> don't write for loops by generating a vector of functors, why would that be
> better here? The bulk execution requirements are a little confusing at
> first, but I think a couple of examples cure that. Most use cases will be
> covered by the parallel algorithms, so few developers will need to interact
> with the complexity.
>
For example, when we are writing a function to choose a best mirror server
from a series a servers specified by their corresponding hosts, we could
probably design a signature like:
std::string choose_best_host(std::vector<std::string> hosts);
The list of hosts could be very long (a lot more than the number of CPUs),
and the evaluations of hosts are IO intensive and pairwise
independent. Under such circumstances, "concurrency" is usually a very
helpful technique to increase performance.
If there is thread pool executor, and we want to reuse it to do the
evaluation of each host, how should we submit the tasks? I think this is
a typical scenario where we should execute the tasks in bulk, and the tasks
are usually stored in containers with corresponding data (in this case,
hosts to evaluate).
On the other hand, "vector" is not the only conatiner. If we are writing a
performance-critical program, and could not tolerate the performance of the
"vector" or any other container in the standard, we are also able to build
some domain-specific containers without unnecessary memory allocation
or assertion.
> 3) Polymorphic executors are specified to correctly deal with require and
> prefer specifications of underlying executors. They need to behave
> correctly under those circumstances, which would mean building on top of
> any general polymorphism interface.
>
With my latest proposal about polymorphism (included in the attachments),
we could design polymorphic modules with the new keyword "facade", e.g.:
facade OnewayExecutor {
void execute(static_proxy<Callable<void()>>) const;
};
.... and we are able to use it with proxies afterwards:
static_proxy<OnewayExecutor> p0;
static_proxy<OnewayExecutor&> p1;
static_proxy<const OnewayExecutor&> p2;
....
More detailes are included in the proposal, and I will appreciate it if
there is any comment or feedback.
> 4) Yes, it is minimal. The goal was never to specify a fully usable thread
> pool - only that some minimal structure be provided such that minimal
> executors can be defined. Trying to specify a perfect thread pool, assuming
> one to exist, would delay the executors specification for no gain.
>
If it is a minimal one, I think it should not support "wait" or "stop"
operations, and should be MoveConstructible. More importantly, the
destructor should be non-blocking.
During my time trying to implement the thread pool with C++, I found it
unnecessary to store the "thread" objects or native handles in the thread
pool, and blocking in the destruction is meaningless. The code below is my
minimum implementation of the thread pool (for exposition;
std::function<void()> could be replaced by any polymorphic wrapper for the
Callables), for your consideration:
#include <mutex>
#include <condition_variable>
#include <functional>
#include <queue>
#include <thread>
class fixed_thread_pool {
public:
explicit fixed_thread_pool(size_t thread_count)
: data_(std::make_shared<data>()) {
for (size_t i = 0; i < thread_count; ++i) {
std::thread([data = data_] {
std::unique_lock<std::mutex> lk(data->mtx_);
for (;;) {
if (!data->tasks_.empty()) {
auto current = std::move(data->tasks_.front());
data->tasks_.pop();
lk.unlock();
current();
lk.lock();
} else if (data->is_shutdown_) {
break;
} else {
data->cond_.wait(lk);
}
}
}).detach();
}
}
fixed_thread_pool() = default;
fixed_thread_pool(fixed_thread_pool&&) = default;
~fixed_thread_pool() {
if ((bool) data_) {
{
std::lock_guard<std::mutex> lk(data_->mtx_);
data_->is_shutdown_ = true;
}
data_->cond_.notify_all();
}
}
template <class F>
void execute(F&& task) {
{
std::lock_guard<std::mutex> lk(data_->mtx_);
data_->tasks_.emplace(std::forward<F>(task));
}
data_->cond_.notify_one();
}
private:
struct data {
std::mutex mtx_;
std::condition_variable cond_;
bool is_shutdown_ = false;
std::queue<std::function<void()>> tasks_;
};
std::shared_ptr<data> data_;
};
Thank you for the reply!
Mingxin Wang
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.org.
------=_Part_15296_1663277179.1522644716121
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Monday, April 2, 2018 at 8:40:00 AM UTC+8, Lee Howes wr=
ote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex=
;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr">1) Multi-=
dimensional iteration spaces are optimal to generate iteration variables on=
some platforms. In general, it is cheaper to flatten an N-dimensional spac=
e than to wrap a one-dimensional one.</div></blockquote><div><br></div><div=
>Why do we need multi-dimensional iteration? Could you provide a meaningful=
use case where it would help in performance?</div><div>=C2=A0</div><blockq=
uote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-lef=
t: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div>2) A collection=
of functors would be an unnecessary pessimisation. We don't write for =
loops by generating a vector of functors, why would that be better here? Th=
e bulk execution requirements are a little confusing at first, but I think =
a couple of examples cure that. Most use cases will be covered by the paral=
lel algorithms, so few developers will need to interact with the complexity=
..</div></div></blockquote><div><br></div><div>For example, when we are writ=
ing a function to choose a best mirror server from a series a servers speci=
fied by their corresponding hosts, we could probably design a signature lik=
e:</div><div><br></div><div><div class=3D"prettyprint" style=3D"background-=
color: rgb(250, 250, 250); border-color: rgb(187, 187, 187); border-style: =
solid; border-width: 1px; word-wrap: break-word;"><code class=3D"prettyprin=
t"><div class=3D"subprettyprint"><span style=3D"font-family: Arial, Helveti=
ca, sans-serif; background-color: rgb(255, 255, 255);"><span style=3D"color=
: #000;" class=3D"styled-by-prettify">std</span></span><span style=3D"font-=
family: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);=
"><span style=3D"color: #660;" class=3D"styled-by-prettify">::</span></span=
><span style=3D"font-family: Arial, Helvetica, sans-serif; background-color=
: rgb(255, 255, 255);"><span style=3D"color: #008;" class=3D"styled-by-pret=
tify">string</span></span><span style=3D"font-family: Arial, Helvetica, san=
s-serif; background-color: rgb(255, 255, 255);"><span style=3D"color: #000;=
" class=3D"styled-by-prettify"> choose_best_host</span></span><span style=
=3D"font-family: Arial, Helvetica, sans-serif; background-color: rgb(255, 2=
55, 255);"><span style=3D"color: #660;" class=3D"styled-by-prettify">(</spa=
n></span><span style=3D"font-family: Arial, Helvetica, sans-serif; backgrou=
nd-color: rgb(255, 255, 255);"><span style=3D"color: #000;" class=3D"styled=
-by-prettify">std</span></span><span style=3D"font-family: Arial, Helvetica=
, sans-serif; background-color: rgb(255, 255, 255);"><span style=3D"color: =
#660;" class=3D"styled-by-prettify">::</span></span><span style=3D"font-fam=
ily: Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"><=
span style=3D"color: #000;" class=3D"styled-by-prettify">vector</span></spa=
n><span style=3D"font-family: Arial, Helvetica, sans-serif; background-colo=
r: rgb(255, 255, 255);"><span style=3D"color: #660;" class=3D"styled-by-pre=
ttify"><</span></span><span style=3D"font-family: Arial, Helvetica, sans=
-serif; background-color: rgb(255, 255, 255);"><span style=3D"color: #000;"=
class=3D"styled-by-prettify">std</span></span><span style=3D"font-family: =
Arial, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"><span =
style=3D"color: #660;" class=3D"styled-by-prettify">::</span></span><span s=
tyle=3D"font-family: Arial, Helvetica, sans-serif; background-color: rgb(25=
5, 255, 255);"><span style=3D"color: #008;" class=3D"styled-by-prettify">st=
ring</span></span><span style=3D"font-family: Arial, Helvetica, sans-serif;=
background-color: rgb(255, 255, 255);"><span style=3D"color: #660;" class=
=3D"styled-by-prettify">></span></span><span style=3D"font-family: Arial=
, Helvetica, sans-serif; background-color: rgb(255, 255, 255);"><span style=
=3D"color: #000;" class=3D"styled-by-prettify"> hosts</span></span><span st=
yle=3D"font-family: Arial, Helvetica, sans-serif; background-color: rgb(255=
, 255, 255);"><span style=3D"color: #660;" class=3D"styled-by-prettify">);<=
/span></span><span style=3D"color: #000;" class=3D"styled-by-prettify"><br>=
</span></div></code></div><br></div><div>The list of hosts could be very lo=
ng (a lot more than the number of CPUs), and the evaluations of hosts are=
=C2=A0IO intensive and=C2=A0pairwise independent.=C2=A0Under such circumsta=
nces, "concurrency" is usually a very helpful technique to increa=
se performance.</div><div><br></div><div>If there is thread pool executor, =
and we want to reuse it to do the evaluation of each host, how should we su=
bmit the tasks? I think this is a=C2=A0typical scenario where we should exe=
cute the tasks in bulk, and the tasks are usually stored in containers with=
corresponding data (in this case, hosts to evaluate).</div><div><br></div>=
<div>On the other hand, "vector" is not the only conatiner. If we=
are writing a performance-critical program, and could not tolerate the per=
formance of the "vector" or any other container in the standard, =
we are also able to build some=C2=A0domain-specific containers without unne=
cessary memory allocation or=C2=A0assertion.</div><div>=C2=A0</div><blockqu=
ote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left=
: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div>3) Polymorphic e=
xecutors are specified to correctly deal with require and prefer specificat=
ions of underlying executors. They need to behave correctly under those cir=
cumstances, which would mean building on top of any general polymorphism in=
terface.</div></div></blockquote><div><br></div><div>With my latest proposa=
l about polymorphism (included in the attachments), we could design polymor=
phic modules with the new keyword "facade", e.g.:</div><div><br><=
/div><div><div class=3D"prettyprint" style=3D"background-color: rgb(250, 25=
0, 250); border-color: rgb(187, 187, 187); border-style: solid; border-widt=
h: 1px; word-wrap: break-word;"><code class=3D"prettyprint"><div class=3D"s=
ubprettyprint"><div class=3D"subprettyprint">facade OnewayExecutor {</div><=
div class=3D"subprettyprint">=C2=A0 void execute(static_proxy<Callable&l=
t;void()>>) const;</div><div class=3D"subprettyprint">};</div></div><=
/code></div><br>... and we are able to use it with proxies afterwards:</div=
><div><br></div><div><div class=3D"prettyprint" style=3D"background-color: =
rgb(250, 250, 250); border-color: rgb(187, 187, 187); border-style: solid; =
border-width: 1px; word-wrap: break-word;"><code class=3D"prettyprint"><div=
class=3D"subprettyprint"><div class=3D"subprettyprint">static_proxy<One=
wayExecutor> p0;</div><div class=3D"subprettyprint">static_proxy<Onew=
ayExecutor&> p1;</div><div class=3D"subprettyprint">static_proxy<=
const OnewayExecutor&> p2;</div><div class=3D"subprettyprint">...</d=
iv></div></code></div><br>More detailes are included in the proposal, and=
=C2=A0I will appreciate it if there is any comment or feedback.</div><div>=
=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-lef=
t: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><=
div>4) Yes, it is minimal. The goal was never to specify a fully usable thr=
ead pool - only that some minimal structure be provided such that minimal e=
xecutors can be defined. Trying to specify a perfect thread pool, assuming =
one to exist, would delay the executors specification for no gain. =C2=A0</=
div></div></blockquote><div><br></div><div>If it is a minimal one, I think =
it should not support "wait" or "stop" operations, and =
should be MoveConstructible. More importantly, the destructor should be non=
-blocking.</div><div><br></div><div>During my time=C2=A0trying to implement=
the thread pool with C++, I found it unnecessary to store the "thread=
" objects or native handles in the thread pool, and blocking in the de=
struction is=C2=A0meaningless. The code below is my minimum implementation =
of the thread pool (for exposition; std::function<void()> could be re=
placed by any polymorphic wrapper for the Callables), for your consideratio=
n:</div><div><br></div><div><div class=3D"prettyprint" style=3D"background-=
color: rgb(250, 250, 250); border-color: rgb(187, 187, 187); border-style: =
solid; border-width: 1px; word-wrap: break-word;"><code class=3D"prettyprin=
t"><div class=3D"subprettyprint"><font color=3D"#660066"><div class=3D"subp=
rettyprint">#include <mutex></div><div class=3D"subprettyprint">#incl=
ude <condition_variable></div><div class=3D"subprettyprint">#include =
<functional></div><div class=3D"subprettyprint">#include <queue>=
;</div><div class=3D"subprettyprint">#include <thread></div><div clas=
s=3D"subprettyprint"><br></div><div class=3D"subprettyprint">class fixed_th=
read_pool {</div><div class=3D"subprettyprint">=C2=A0public:</div><div clas=
s=3D"subprettyprint">=C2=A0 explicit fixed_thread_pool(size_t thread_count)=
</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 : data_(std::make_=
shared<data>()) {</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 fo=
r (size_t i =3D 0; i < thread_count; ++i) {</div><div class=3D"subpretty=
print">=C2=A0 =C2=A0 =C2=A0 std::thread([data =3D data_] {</div><div class=
=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 std::unique_lock<std::mu=
tex> lk(data->mtx_);</div><div class=3D"subprettyprint">=C2=A0 =C2=A0=
=C2=A0 =C2=A0 for (;;) {</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0 if (!data->tasks_.empty()) {</div><div class=3D"sub=
prettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 auto current =3D std=
::move(data->tasks_.front());</div><div class=3D"subprettyprint">=C2=A0 =
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 data->tasks_.pop();</div><div class=
=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 lk.unlock();<=
/div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 current();</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 lk.lock();</div><div class=3D"subprettyprint">=C2=A0 =C2=
=A0 =C2=A0 =C2=A0 =C2=A0 } else if (data->is_shutdown_) {</div><div clas=
s=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 break;</div>=
<div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } else {</=
div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0=
data->cond_.wait(lk);</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0 }</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=
=A0 =C2=A0 }</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 }).det=
ach();</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 }</div><div class=
=3D"subprettyprint">=C2=A0 }</div><div class=3D"subprettyprint"><br></div><=
div class=3D"subprettyprint">=C2=A0 fixed_thread_pool() =3D default;</div><=
div class=3D"subprettyprint">=C2=A0 fixed_thread_pool(fixed_thread_pool&=
;&) =3D default;</div><div class=3D"subprettyprint"><br></div><div clas=
s=3D"subprettyprint">=C2=A0 ~fixed_thread_pool() {</div><div class=3D"subpr=
ettyprint">=C2=A0 =C2=A0 if ((bool) data_) {</div><div class=3D"subprettypr=
int">=C2=A0 =C2=A0 =C2=A0 {</div><div class=3D"subprettyprint">=C2=A0 =C2=
=A0 =C2=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_->mtx_);</di=
v><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 data_->is_sh=
utdown_ =3D true;</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 }=
</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 data_->cond_.no=
tify_all();</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 }</div><div cl=
ass=3D"subprettyprint">=C2=A0 }</div><div class=3D"subprettyprint"><br></di=
v><div class=3D"subprettyprint">=C2=A0 template <class F></div><div c=
lass=3D"subprettyprint">=C2=A0 void execute(F&& task) {</div><div c=
lass=3D"subprettyprint">=C2=A0 =C2=A0 {</div><div class=3D"subprettyprint">=
=C2=A0 =C2=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_->mtx_);<=
/div><div class=3D"subprettyprint">=C2=A0 =C2=A0 =C2=A0 data_->tasks_.em=
place(std::forward<F>(task));</div><div class=3D"subprettyprint">=C2=
=A0 =C2=A0 }</div><div class=3D"subprettyprint">=C2=A0 =C2=A0 data_->con=
d_.notify_one();</div><div class=3D"subprettyprint">=C2=A0 }</div><div clas=
s=3D"subprettyprint"><br></div><div class=3D"subprettyprint">=C2=A0private:=
</div><div class=3D"subprettyprint">=C2=A0 struct data {</div><div class=3D=
"subprettyprint">=C2=A0 =C2=A0 std::mutex mtx_;</div><div class=3D"subprett=
yprint">=C2=A0 =C2=A0 std::condition_variable cond_;</div><div class=3D"sub=
prettyprint">=C2=A0 =C2=A0 bool is_shutdown_ =3D false;</div><div class=3D"=
subprettyprint">=C2=A0 =C2=A0 std::queue<std::function<void()>>=
tasks_;</div><div class=3D"subprettyprint">=C2=A0 };</div><div class=3D"su=
bprettyprint">=C2=A0 std::shared_ptr<data> data_;</div><div class=3D"=
subprettyprint">};<br></div></font></div></code></div><br>Thank you for the=
reply!</div><div><br></div><div>Mingxin Wang</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0=
%40isocpp.org</a>.<br />
------=_Part_15296_1663277179.1522644716121--
------=_Part_15295_866340481.1522644716120
Content-Type: application/pdf; name=d0957r1.pdf
Content-Transfer-Encoding: base64
Content-Disposition: attachment; filename=d0957r1.pdf
X-Attachment-Id: 78ccf631-b037-444b-b65c-58140b6c1426
Content-ID: <78ccf631-b037-444b-b65c-58140b6c1426>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=
------=_Part_15295_866340481.1522644716120--
.
Author: =?UTF-8?Q?Klaim_=2D_Jo=C3=ABl_Lamotte?= <mjklaim@gmail.com>
Date: Mon, 2 Apr 2018 15:15:27 +0200
Raw View
--0000000000008e5a080568dd64d0
Content-Type: text/plain; charset="UTF-8"
On 2 April 2018 at 06:51, Mingxin Wang <wmx16835vv@163.com> wrote:
>
> 3) Polymorphic executors are specified to correctly deal with require and
>> prefer specifications of underlying executors. They need to behave
>> correctly under those circumstances, which would mean building on top of
>> any general polymorphism interface.
>>
>
> With my latest proposal about polymorphism (included in the attachments),
> we could design polymorphic modules with the new keyword "facade", e.g.:
>
> facade OnewayExecutor {
> void execute(static_proxy<Callable<void()>>) const;
> };
>
> ... and we are able to use it with proxies afterwards:
>
> static_proxy<OnewayExecutor> p0;
> static_proxy<OnewayExecutor&> p1;
> static_proxy<const OnewayExecutor&> p2;
> ...
>
> More detailes are included in the proposal, and I will appreciate it if
> there is any comment or feedback.
>
Although your proposal is interesting, this is only an implementation
detail of the polymorphic executors (which are already necessary in some
ways today) specification.
I don't know if your proposal is enough to implement these polymorphic
executors, but the specification only is concerned with the resulting
interface.
By the way, how would you specify a polymorphic executor using a
composition of several requirements (some might be custom), as the proposal
requests?
>
>
>> 4) Yes, it is minimal. The goal was never to specify a fully usable
>> thread pool - only that some minimal structure be provided such that
>> minimal executors can be defined. Trying to specify a perfect thread pool,
>> assuming one to exist, would delay the executors specification for no gain.
>>
>>
>
> If it is a minimal one, I think it should not support "wait" or "stop"
> operations, and should be MoveConstructible. More importantly, the
> destructor should be non-blocking.
>
>
I don't think that's possible.
There is a need, in my experience, for an explicit synchronization point
with all the underlying threads to be able to make sense of the program.
For example in your following example, the tasks pushed in that thread pool
can survive the lifetime of the thread pool. That makes
reasoning almost impossible. To put it another way: it goes against RAII
principles and definitely is not the good way to go.
Anyway, the proposal is not supposed to provide much in thread pools and
other proposals will provide these, in variety I suppose (or predict).
> During my time trying to implement the thread pool with C++, I found it
> unnecessary to store the "thread" objects or native handles in the thread
> pool, and blocking in the destruction is meaningless. The code below is my
> minimum implementation of the thread pool (for exposition;
> std::function<void()> could be replaced by any polymorphic wrapper for the
> Callables), for your consideration:
>
> #include <mutex>
> #include <condition_variable>
> #include <functional>
> #include <queue>
> #include <thread>
>
> class fixed_thread_pool {
> public:
> explicit fixed_thread_pool(size_t thread_count)
> : data_(std::make_shared<data>()) {
> for (size_t i = 0; i < thread_count; ++i) {
> std::thread([data = data_] {
> std::unique_lock<std::mutex> lk(data->mtx_);
> for (;;) {
> if (!data->tasks_.empty()) {
> auto current = std::move(data->tasks_.front());
> data->tasks_.pop();
> lk.unlock();
> current();
> lk.lock();
> } else if (data->is_shutdown_) {
> break;
> } else {
> data->cond_.wait(lk);
> }
> }
> }).detach();
> }
> }
>
> fixed_thread_pool() = default;
> fixed_thread_pool(fixed_thread_pool&&) = default;
>
> ~fixed_thread_pool() {
> if ((bool) data_) {
> {
> std::lock_guard<std::mutex> lk(data_->mtx_);
> data_->is_shutdown_ = true;
> }
> data_->cond_.notify_all();
> }
> }
>
> template <class F>
> void execute(F&& task) {
> {
> std::lock_guard<std::mutex> lk(data_->mtx_);
> data_->tasks_.emplace(std::forward<F>(task));
> }
> data_->cond_.notify_one();
> }
>
> private:
> struct data {
> std::mutex mtx_;
> std::condition_variable cond_;
> bool is_shutdown_ = false;
> std::queue<std::function<void()>> tasks_;
> };
> std::shared_ptr<data> data_;
> };
>
> Thank you for the reply!
>
>
That's under-performant because of the task queue being shared by all the
threads.
> Mingxin Wang
>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-
> 8783-07b3f38f84e0%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=email&utm_source=footer>
> .
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OPvGR0dRfuGp8bcc52csLu%3DczoOqtEWieDvHKNMUu_kzg%40mail.gmail.com.
--0000000000008e5a080568dd64d0
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 2 April 2018 at 06:51, Mingxin Wang <span dir=3D"ltr"><<a href=3D=
"mailto:wmx16835vv@163.com" target=3D"_blank">wmx16835vv@163.com</a>></s=
pan> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex=
;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><br><span cl=
ass=3D""><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.=
8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div>3) P=
olymorphic executors are specified to correctly deal with require and prefe=
r specifications of underlying executors. They need to behave correctly und=
er those circumstances, which would mean building on top of any general pol=
ymorphism interface.</div></div></blockquote><div><br></div></span><div>Wit=
h my latest proposal about polymorphism (included in the attachments), we c=
ould design polymorphic modules with the new keyword "facade", e.=
g.:</div><div><br></div><div><div class=3D"m_-5596982869335057142prettyprin=
t" style=3D"background-color:rgb(250,250,250);border-color:rgb(187,187,187)=
;border-style:solid;border-width:1px;word-wrap:break-word"><code class=3D"m=
_-5596982869335057142prettyprint"><div class=3D"m_-5596982869335057142subpr=
ettyprint"><div class=3D"m_-5596982869335057142subprettyprint">facade Onewa=
yExecutor {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0=
void execute(static_proxy<Callable<<wbr>void()>>) const;</div>=
<div class=3D"m_-5596982869335057142subprettyprint">};</div></div></code></=
div><br>... and we are able to use it with proxies afterwards:</div><div><b=
r></div><div><div class=3D"m_-5596982869335057142prettyprint" style=3D"back=
ground-color:rgb(250,250,250);border-color:rgb(187,187,187);border-style:so=
lid;border-width:1px;word-wrap:break-word"><code class=3D"m_-55969828693350=
57142prettyprint"><div class=3D"m_-5596982869335057142subprettyprint"><div =
class=3D"m_-5596982869335057142subprettyprint">static_proxy<OnewayExecut=
or> p0;</div><div class=3D"m_-5596982869335057142subprettyprint">static_=
proxy<OnewayExecutor&> p1;</div><div class=3D"m_-5596982869335057=
142subprettyprint">static_proxy<const OnewayExecutor&> p2;</div><=
div class=3D"m_-5596982869335057142subprettyprint">...</div></div></code></=
div><br>More detailes are included in the proposal, and=C2=A0I will appreci=
ate it if there is any comment or feedback.</div><span class=3D""><div></di=
v></span></div></blockquote><div><br></div><div><br></div><div>Although you=
r proposal is interesting, this is only an implementation detail of the pol=
ymorphic executors (which are already necessary in some ways today) specifi=
cation.</div><div>I don't know if your proposal is enough to implement =
these polymorphic executors, but the specification only is concerned with t=
he resulting interface.</div><div><br></div><div>By the way, how would=C2=
=A0 you specify a polymorphic executor using a composition of several requi=
rements (some might be custom), as the proposal requests?</div><div>=C2=A0<=
/div><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-le=
ft:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span class=3D""><div>=
=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left=
:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div>4=
) Yes, it is minimal. The goal was never to specify a fully usable thread p=
ool - only that some minimal structure be provided such that minimal execut=
ors can be defined. Trying to specify a perfect thread pool, assuming one t=
o exist, would delay the executors specification for no gain. =C2=A0</div><=
/div></blockquote><div><br></div></span><div>If it is a minimal one, I thin=
k it should not support "wait" or "stop" operations, an=
d should be MoveConstructible. More importantly, the destructor should be n=
on-blocking.</div><div><br></div></div></blockquote><div><br></div><div>I d=
on't think that's possible.</div><div>There is a need, in my experi=
ence, for an explicit synchronization point with all the underlying threads=
to be able to make sense of the program.</div><div>For example in your fol=
lowing example, the tasks pushed in that thread pool can survive the lifeti=
me of the thread pool. That makes=C2=A0</div><div>reasoning almost impossib=
le. To put it another way: it goes against RAII principles and definitely i=
s not the good way to go.</div><div><br></div><div>Anyway, the proposal is =
not supposed to provide much in thread pools and other proposals will provi=
de these, in variety I suppose (or predict).</div><div>=C2=A0</div><blockqu=
ote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc s=
olid;padding-left:1ex"><div dir=3D"ltr"><div></div><div>During my time=C2=
=A0trying to implement the thread pool with C++, I found it unnecessary to =
store the "thread" objects or native handles in the thread pool, =
and blocking in the destruction is=C2=A0meaningless. The code below is my m=
inimum implementation of the thread pool (for exposition; std::function<=
void()> could be replaced by any polymorphic wrapper for the Callables),=
for your consideration:</div><div><br></div><div><div class=3D"m_-55969828=
69335057142prettyprint" style=3D"background-color:rgb(250,250,250);border-c=
olor:rgb(187,187,187);border-style:solid;border-width:1px;word-wrap:break-w=
ord"><code class=3D"m_-5596982869335057142prettyprint"><div class=3D"m_-559=
6982869335057142subprettyprint"><font color=3D"#660066"><div class=3D"m_-55=
96982869335057142subprettyprint">#include <mutex></div><div class=3D"=
m_-5596982869335057142subprettyprint">#include <condition_variable></=
div><div class=3D"m_-5596982869335057142subprettyprint">#include <functi=
onal></div><div class=3D"m_-5596982869335057142subprettyprint">#include =
<queue></div><div class=3D"m_-5596982869335057142subprettyprint">#inc=
lude <thread></div><div class=3D"m_-5596982869335057142subprettyprint=
"><br></div><div class=3D"m_-5596982869335057142subprettyprint">class fixed=
_thread_pool {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=
=A0public:</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =
explicit fixed_thread_pool(size_t thread_count)</div><div class=3D"m_-55969=
82869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 : data_(std::make_shared=
<data>()<wbr>) {</div><div class=3D"m_-5596982869335057142subprettypr=
int">=C2=A0 =C2=A0 for (size_t i =3D 0; i < thread_count; ++i) {</div><d=
iv class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 std:=
:thread([data =3D data_] {</div><div class=3D"m_-5596982869335057142subpret=
typrint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 std::unique_lock<std::mutex> lk(=
data->mtx_);</div><div class=3D"m_-5596982869335057142subprettyprint">=
=C2=A0 =C2=A0 =C2=A0 =C2=A0 for (;;) {</div><div class=3D"m_-55969828693350=
57142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 if (!data->tasks=
_.empty()) {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=
=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 auto current =3D std::move(data->=
tasks_.front()<wbr>);</div><div class=3D"m_-5596982869335057142subprettypri=
nt">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 data->tasks_.pop();</div><=
div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 lk.unlock();</div><div class=3D"m_-5596982869335057142sub=
prettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 current();</div><div=
class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0=
=C2=A0 =C2=A0 lk.lock();</div><div class=3D"m_-5596982869335057142subprett=
yprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } else if (data->is_shutdown_=
) {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0 =C2=A0 break;</div><div class=3D"m_-559698286933505714=
2subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } else {</div><div clas=
s=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 data->cond_.wait(lk);</div><div class=3D"m_-55969828693350571=
42subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 }</div><div class=3D"m=
_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =C2=A0 }</div><di=
v class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 }).de=
tach();</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=
=A0 }</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 }</di=
v><div class=3D"m_-5596982869335057142subprettyprint"><br></div><div class=
=3D"m_-5596982869335057142subprettyprint">=C2=A0 fixed_thread_pool() =3D de=
fault;</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 fixe=
d_thread_pool(fixed_<wbr>thread_pool&&) =3D default;</div><div clas=
s=3D"m_-5596982869335057142subprettyprint"><br></div><div class=3D"m_-55969=
82869335057142subprettyprint">=C2=A0 ~fixed_thread_pool() {</div><div class=
=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 if ((bool) data_) {=
</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=
=A0 {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=
=A0 =C2=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_->mtx_);</di=
v><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =
=C2=A0 data_->is_shutdown_ =3D true;</div><div class=3D"m_-5596982869335=
057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 }</div><div class=3D"m_-55969828=
69335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 data_->cond_.notify_all(=
);</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 }=
</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 }</div><di=
v class=3D"m_-5596982869335057142subprettyprint"><br></div><div class=3D"m_=
-5596982869335057142subprettyprint">=C2=A0 template <class F></div><d=
iv class=3D"m_-5596982869335057142subprettyprint">=C2=A0 void execute(F&=
;& task) {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=
=A0 =C2=A0 {</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=
=A0 =C2=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_->mtx_);</di=
v><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 =C2=A0 =
data_->tasks_.emplace(std::<wbr>forward<F>(task));</div><div class=
=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 }</div><div class=
=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 data_->cond_.not=
ify_one();</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =
}</div><div class=3D"m_-5596982869335057142subprettyprint"><br></div><div c=
lass=3D"m_-5596982869335057142subprettyprint">=C2=A0private:</div><div clas=
s=3D"m_-5596982869335057142subprettyprint">=C2=A0 struct data {</div><div c=
lass=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 std::mutex mtx_=
;</div><div class=3D"m_-5596982869335057142subprettyprint">=C2=A0 =C2=A0 st=
d::condition_variable cond_;</div><div class=3D"m_-5596982869335057142subpr=
ettyprint">=C2=A0 =C2=A0 bool is_shutdown_ =3D false;</div><div class=3D"m_=
-5596982869335057142subprettyprint">=C2=A0 =C2=A0 std::queue<std::functi=
on<void(<wbr>)>> tasks_;</div><div class=3D"m_-5596982869335057142=
subprettyprint">=C2=A0 };</div><div class=3D"m_-5596982869335057142subprett=
yprint">=C2=A0 std::shared_ptr<data> data_;</div><div class=3D"m_-559=
6982869335057142subprettyprint">};<br></div></font></div></code></div><br>T=
hank you for the reply!</div><div><br></div></div></blockquote><div><br></d=
iv><div>That's under-performant because of the task queue being shared =
by all the threads.</div><div><br></div><div>=C2=A0</div><blockquote class=
=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padd=
ing-left:1ex"><div dir=3D"ltr"><div></div><div>Mingxin Wang</div></div><spa=
n class=3D"">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/35f0=
c5a1-5d16-4bbf-<wbr>8783-07b3f38f84e0%40isocpp.org</a><wbr>.<br>
</blockquote></div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOU91OPvGR0dRfuGp8bcc52csLu%3DczoOqt=
EWieDvHKNMUu_kzg%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OPvGR0dRf=
uGp8bcc52csLu%3DczoOqtEWieDvHKNMUu_kzg%40mail.gmail.com</a>.<br />
--0000000000008e5a080568dd64d0--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Mon, 2 Apr 2018 08:40:14 -0700 (PDT)
Raw View
------=_Part_419_996111149.1522683614914
Content-Type: multipart/alternative;
boundary="----=_Part_420_736532412.1522683614915"
------=_Part_420_736532412.1522683614915
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=ABl Lamotte wro=
te:
> On 2 April 2018 at 06:51, Mingxin Wang <wmx16...@163.com> wrote:
>
>>
>> With my latest proposal about polymorphism (included in the attachments)=
,=20
>> we could design polymorphic modules with the new keyword "facade", e.g.:
>>
>> facade OnewayExecutor {
>> void execute(static_proxy<Callable<void()>>) const;
>> };
>>
>> ... and we are able to use it with proxies afterwards:
>>
>> static_proxy<OnewayExecutor> p0;
>> static_proxy<OnewayExecutor&> p1;
>> static_proxy<const OnewayExecutor&> p2;
>> ...
>>
>> More detailes are included in the proposal, and I will appreciate it if=
=20
>> there is any comment or feedback.
>>
>
>
> Although your proposal is interesting, this is only an implementation=20
> detail of the polymorphic executors (which are already necessary in some=
=20
> ways today) specification.
> I don't know if your proposal is enough to implement these polymorphic=20
> executors, but the specification only is concerned with the resulting=20
> interface.
>
Built-in addresser template (aka. `static_proxy`) has similar interface=20
with `std::any` in constructors and observers.
=20
> By the way, how would you specify a polymorphic executor using a=20
> composition of several requirements (some might be custom), as the propos=
al=20
> requests?
>
The "facade" are compatible to the C++ type system, including but not=20
limited to inheritance, overloading, templates, and qualifiers. For=20
example, we are able to define a facade template `Callable` to replace the=
=20
class template `std::function`:
template <class T>
facade Callable; // undefined
template <class R, class... Args>
facade Callable<R(Args...)> {
R operator(Args... args);
};
.... and we could define a series of facades for the executors:
facade OneWayExecutor {
void execute(static_proxy<Callable<void()>> f) const;
};
template <class T>
facade TwoWayExecutor {
std::experimental::future<T>=20
twoway_execute(static_proxy<Callable<void()>> f) const;
};
.... and we can also define other facades based on them if necessary:
facade MyExecutor : OneWayExecutor, TwoWayExecutor {
void wait_for_all_tasks_to_be_done_or_something();
void reset_worker_count(std::size_t new_count);
static std::string some_type_specific_description();
};
Providing there is a type `my_awesome_executor` meets the requirements=20
defined by the facade, the following code shows its basic usage:
const my_awesome_executor ex;
static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is not=
=20
convertible to `non-const` reference;
static_proxy<const MyExecutor&> p1(ex); // OK;
static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called;
static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructor is=
=20
called;
std::cout << p3.type() << std::endl; // OK; Print the result of=20
`typeid(my_awesome_executor)`;
static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value is=20
convertible to `const` reference;
static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK; `non-volatile`=
=20
value is convertible to `volatile` value;
std::cout << p3.has_value() << std::endl; // OK; Print `false`, because=20
the value has been moved to `p5`;
p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // OK;
p5.execute([] { std::cout << "Although bad things happen sometimes..." <<=
=20
std::endl; }); // Error; The `execute` function is not `volatile`;
=20
>>
>>> 4) Yes, it is minimal. The goal was never to specify a fully usable=20
>>> thread pool - only that some minimal structure be provided such that=20
>>> minimal executors can be defined. Trying to specify a perfect thread po=
ol,=20
>>> assuming one to exist, would delay the executors specification for no g=
ain.=20
>>> =20
>>>
>>
>> If it is a minimal one, I think it should not support "wait" or "stop"=
=20
>> operations, and should be MoveConstructible. More importantly, the=20
>> destructor should be non-blocking.
>>
>>
> I don't think that's possible.
> There is a need, in my experience, for an explicit synchronization point=
=20
> with all the underlying threads to be able to make sense of the program.
>
I think that is what the users should concern about, not us. Users could=20
use latches, futures or some other structural support utilities proposed in=
=20
another paper of mine (P0642) to control the flow.
=20
> For example in your following example, the tasks pushed in that thread=20
> pool can survive the lifetime of the thread pool. That makes=20
> reasoning almost impossible. To put it another way: it goes against RAII=
=20
> principles and definitely is not the good way to go.
>
I do not understand how you come to the conclusion that "it goes against=20
RAII principles". If my understanding is right, RAII is about "initializing=
=20
the resource when it is acquired", and I did not find my code against this=
=20
principle. Is there anything I missed?
Actually, this implementation could be abused if one does not have the=20
ability to write concurrent programs correctly. This phenomenon is common=
=20
in the whole C++ programming language, not only at this point.
Anyway, the proposal is not supposed to provide much in thread pools and=20
> other proposals will provide these, in variety I suppose (or predict).
>
I will be grateful if you could provide any relevant information.
=20
> During my time trying to implement the thread pool with C++, I found it=
=20
>> unnecessary to store the "thread" objects or native handles in the threa=
d=20
>> pool, and blocking in the destruction is meaningless. The code below is =
my=20
>> minimum implementation of the thread pool (for exposition;=20
>> std::function<void()> could be replaced by any polymorphic wrapper for t=
he=20
>> Callables), for your consideration:
>>
>> #include <mutex>
>> #include <condition_variable>
>> #include <functional>
>> #include <queue>
>> #include <thread>
>>
>> class fixed_thread_pool {
>> public:
>> explicit fixed_thread_pool(size_t thread_count)
>> : data_(std::make_shared<data>()) {
>> for (size_t i =3D 0; i < thread_count; ++i) {
>> std::thread([data =3D data_] {
>> std::unique_lock<std::mutex> lk(data->mtx_);
>> for (;;) {
>> if (!data->tasks_.empty()) {
>> auto current =3D std::move(data->tasks_.front());
>> data->tasks_.pop();
>> lk.unlock();
>> current();
>> lk.lock();
>> } else if (data->is_shutdown_) {
>> break;
>> } else {
>> data->cond_.wait(lk);
>> }
>> }
>> }).detach();
>> }
>> }
>>
>> fixed_thread_pool() =3D default;
>> fixed_thread_pool(fixed_thread_pool&&) =3D default;
>>
>> ~fixed_thread_pool() {
>> if ((bool) data_) {
>> {
>> std::lock_guard<std::mutex> lk(data_->mtx_);
>> data_->is_shutdown_ =3D true;
>> }
>> data_->cond_.notify_all();
>> }
>> }
>>
>> template <class F>
>> void execute(F&& task) {
>> {
>> std::lock_guard<std::mutex> lk(data_->mtx_);
>> data_->tasks_.emplace(std::forward<F>(task));
>> }
>> data_->cond_.notify_one();
>> }
>>
>> private:
>> struct data {
>> std::mutex mtx_;
>> std::condition_variable cond_;
>> bool is_shutdown_ =3D false;
>> std::queue<std::function<void()>> tasks_;
>> };
>> std::shared_ptr<data> data_;
>> };
>>
>> Thank you for the reply!
>>
>>
> That's under-performant because of the task queue being shared by all the=
=20
> threads.
>
I would appreciate it if you could provide a better implementation and=20
benchmark.
Mingxin Wang
>>
>> --=20
>> You received this message because you are subscribed to the Google Group=
s=20
>> "ISO C++ Standard - Future Proposals" group.
>> To unsubscribe from this group and stop receiving emails from it, send a=
n=20
>> email to std-proposal...@isocpp.org.
>> To post to this group, send email to std-pr...@isocpp.org.
>> To view this discussion on the web visit=20
>> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d=
16-4bbf-8783-07b3f38f84e0%40isocpp.org=20
>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5=
d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoo=
ter>
>> .
>>
>
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/d94c1947-531c-40e5-8f10-bc2b917c84a9%40isocpp.or=
g.
------=_Part_420_736532412.1522683614915
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><div>On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim -=
Jo=C3=ABl Lamotte wrote:<br></div><blockquote class=3D"gmail_quote" style=
=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px solid rgb(204, 204, 204); p=
adding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote">On 2 April 2=
018 at 06:51, Mingxin Wang=C2=A0<span dir=3D"ltr"><<a target=3D"_blank" =
gdf-obfuscated-mailto=3D"J5tlypk0BQAJ" rel=3D"nofollow" style=3D"color: rgb=
(102, 17, 204);">wmx16...@163.com</a>></span>=C2=A0wrote:<br><blockquote=
class=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px=
solid rgb(204, 204, 204); padding-left: 1ex;"><div dir=3D"ltr"><div><br></=
div><div>With my latest proposal about polymorphism (included in the attach=
ments), we could design polymorphic modules with the new keyword "faca=
de", e.g.:</div><div><br></div><div><div style=3D"border-width: 1px; b=
order-style: solid; border-color: rgb(187, 187, 187); background-color: rgb=
(250, 250, 250); word-wrap: break-word;"><code><div>facade OnewayExecutor {=
</div><div>=C2=A0 void execute(static_proxy<Callable<<wbr>void()>&=
gt;) const;</div><div>};</div></code></div><br>... and we are able to use i=
t with proxies afterwards:</div><div><br></div><div><div style=3D"border-wi=
dth: 1px; border-style: solid; border-color: rgb(187, 187, 187); background=
-color: rgb(250, 250, 250); word-wrap: break-word;"><code><div>static_proxy=
<OnewayExecutor> p0;</div><div>static_proxy<OnewayExecutor&>=
; p1;</div><div>static_proxy<const OnewayExecutor&> p2;</div><div=
>...</div></code></div><br>More detailes are included in the proposal, and=
=C2=A0I will appreciate it if there is any comment or feedback.</div><div><=
/div></div></blockquote><div><br></div><div><br></div><div>Although your pr=
oposal is interesting, this is only an implementation detail of the polymor=
phic executors (which are already necessary in some ways today) specificati=
on.</div><div>I don't know if your proposal is enough to implement thes=
e polymorphic executors, but the specification only is concerned with the r=
esulting interface.</div></div></div></blockquote><div><br></div><div>Built=
-in addresser template (aka. `static_proxy`) has similar interface with `st=
d::any` in constructors and observers.</div><div>=C2=A0</div><blockquote cl=
ass=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px so=
lid rgb(204, 204, 204); padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"=
gmail_quote">By the way, how would=C2=A0 you specify a polymorphic executor=
using a composition of several requirements (some might be custom), as the=
proposal requests?</div></div></blockquote><div><br></div><div>The "f=
acade" are compatible to the C++ type system, including but not limite=
d to inheritance, overloading, templates, and qualifiers. For example, we a=
re able to define a facade template `Callable` to replace the class templat=
e `std::function`:</div><div><br></div><div><div class=3D"prettyprint" styl=
e=3D"border-width: 1px; border-style: solid; border-color: rgb(187, 187, 18=
7); background-color: rgb(250, 250, 250); word-wrap: break-word;"><code cla=
ss=3D"prettyprint"><div class=3D"subprettyprint"><font color=3D"#660066"><d=
iv class=3D"subprettyprint">template <class T></div><div class=3D"sub=
prettyprint">facade Callable; =C2=A0// undefined</div><div class=3D"subpret=
typrint"><br></div><div class=3D"subprettyprint">template <class R, clas=
s... Args></div><div class=3D"subprettyprint">facade Callable<R(Args.=
...)> {</div><div class=3D"subprettyprint">=C2=A0 R operator(Args... args=
);</div><div class=3D"subprettyprint">};</div></font></div></code></div><br=
>... and we could define a series of facades for the executors:</div><div><=
br></div><div><div class=3D"prettyprint" style=3D"border-width: 1px; border=
-style: solid; border-color: rgb(187, 187, 187); background-color: rgb(250,=
250, 250); word-wrap: break-word;"><code class=3D"prettyprint"><div class=
=3D"subprettyprint"><font color=3D"#660066"><div class=3D"subprettyprint">f=
acade OneWayExecutor {</div><div class=3D"subprettyprint">=C2=A0 void execu=
te(static_proxy<Callable<void()>> f) const;</div><div class=3D"=
subprettyprint">};</div><div class=3D"subprettyprint"><br></div><div class=
=3D"subprettyprint">template <class T></div><div class=3D"subprettypr=
int">facade TwoWayExecutor {</div><div class=3D"subprettyprint">=C2=A0 std:=
:experimental::future<T> twoway_execute(static_proxy<Callable<v=
oid()>> f) const;</div><div class=3D"subprettyprint">};</div></font><=
/div></code></div><br>... and we can also define other facades based on the=
m if necessary:</div><div><br></div><div><div class=3D"prettyprint" style=
=3D"border-width: 1px; border-style: solid; border-color: rgb(187, 187, 187=
); background-color: rgb(250, 250, 250); word-wrap: break-word;"><code clas=
s=3D"prettyprint"><div class=3D"subprettyprint"><div class=3D"subprettyprin=
t"><div class=3D"subprettyprint">facade MyExecutor : OneWayExecutor, TwoWay=
Executor {</div><div class=3D"subprettyprint">=C2=A0 void wait_for_all_task=
s_to_be_done_or_something();</div><div class=3D"subprettyprint">=C2=A0 void=
reset_worker_count(std::size_t new_count);</div><div class=3D"subprettypri=
nt">=C2=A0 static std::string some_type_specific_description();</div><div c=
lass=3D"subprettyprint">};</div></div></div></code></div><br>Providing ther=
e is a type `my_awesome_executor` meets the requirements defined by the fac=
ade, the following code shows its basic usage:</div><div><br></div><div><di=
v class=3D"prettyprint" style=3D"background-color: rgb(250, 250, 250); bord=
er-color: rgb(187, 187, 187); border-style: solid; border-width: 1px; word-=
wrap: break-word;"><code class=3D"prettyprint"><div class=3D"subprettyprint=
"><div class=3D"subprettyprint">const my_awesome_executor ex;</div><div cla=
ss=3D"subprettyprint">static_proxy<MyExecutor&> p0(ex); =C2=A0// =
Error; Because `const` value is not convertible to `non-const` reference;</=
div><div class=3D"subprettyprint">static_proxy<const MyExecutor&>=
p1(ex); =C2=A0// OK;</div><div class=3D"subprettyprint">static_proxy<My=
Executor> p2(ex); =C2=A0// OK; The copy-constructor is called;</div><div=
class=3D"subprettyprint">static_proxy<MyExecutor> p3(std::move(ex));=
=C2=A0// OK; The move-constructor is called;</div><div class=3D"subprettyp=
rint">std::cout << p3.type() << std::endl; =C2=A0// OK; Print t=
he result of `typeid(my_awesome_executor)`;</div><div class=3D"subprettypri=
nt">static_proxy<const OneWayExecutor&> p4(p2); =C2=A0// OK; `non=
-const` value is convertible to `const` reference;</div><div class=3D"subpr=
ettyprint">static_proxy<volatile MyExecutor> p5(std::move(p3)); =C2=
=A0// OK; `non-volatile` value is convertible to `volatile` value;</div><di=
v class=3D"subprettyprint">std::cout << p3.has_value() << std::=
endl; =C2=A0// OK; Print `false`, because the value has been moved to `p5`;=
</div><div class=3D"subprettyprint">p4.execute([] { std::cout << &quo=
t;Life is so cool!" << std::endl; }); =C2=A0// OK;</div><div cla=
ss=3D"subprettyprint">p5.execute([] { std::cout << "Although bad=
things happen sometimes..." << std::endl; }); =C2=A0// Error; T=
he `execute` function is not `volatile`;</div></div></code></div></div><div=
><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0=
..8ex; border-left: 1px solid rgb(204, 204, 204); padding-left: 1ex;"><div d=
ir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" sty=
le=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px solid rgb(204, 204, 204);=
padding-left: 1ex;"><div dir=3D"ltr"><div>=C2=A0</div><blockquote class=3D=
"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px solid rg=
b(204, 204, 204); padding-left: 1ex;"><div dir=3D"ltr">4) Yes, it is minima=
l. The goal was never to specify a fully usable thread pool - only that som=
e minimal structure be provided such that minimal executors can be defined.=
Trying to specify a perfect thread pool, assuming one to exist, would dela=
y the executors specification for no gain. =C2=A0</div></blockquote><div><b=
r></div><div>If it is a minimal one, I think it should not support "wa=
it" or "stop" operations, and should be MoveConstructible. M=
ore importantly, the destructor should be non-blocking.</div><div><br></div=
></div></blockquote><div><br></div><div>I don't think that's possib=
le.</div><div>There is a need, in my experience, for an explicit synchroniz=
ation point with all the underlying threads to be able to make sense of the=
program.</div></div></div></blockquote><div><br></div><div>I think that is=
what the users should concern about, not us. Users could use latches, futu=
res or some other structural support utilities proposed in another paper of=
mine (P0642) to control the flow.</div><div>=C2=A0</div><blockquote class=
=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px solid=
rgb(204, 204, 204); padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gma=
il_quote"><div>For example in your following example, the tasks pushed in t=
hat thread pool can survive the lifetime of the thread pool. That makes=C2=
=A0</div><div>reasoning almost impossible. To put it another way: it goes a=
gainst RAII principles and definitely is not the good way to go.</div></div=
></div></blockquote><div><br></div><div>I do not understand how you come to=
the conclusion that "it goes against RAII principles". If my und=
erstanding is right, RAII is about "initializing the resource when it =
is acquired", and I did not find my code against this principle. Is th=
ere anything I missed?</div><div><br></div><div>Actually, this implementati=
on could be abused if one does not have the ability to write concurrent pro=
grams correctly. This=C2=A0phenomenon is common in the whole C++ programmin=
g language, not only at this point.</div><div><br></div><blockquote class=
=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px solid=
rgb(204, 204, 204); padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gma=
il_quote"><div>Anyway, the proposal is not supposed to provide much in thre=
ad pools and other proposals will provide these, in variety I suppose (or p=
redict).</div></div></div></blockquote><div><br></div><div>I will be gratef=
ul if you could provide any relevant information.<br></div><div>=C2=A0</div=
><blockquote class=3D"gmail_quote" style=3D"margin: 0px 0px 0px 0.8ex; bord=
er-left: 1px solid rgb(204, 204, 204); padding-left: 1ex;"><div dir=3D"ltr"=
><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"marg=
in: 0px 0px 0px 0.8ex; border-left: 1px solid rgb(204, 204, 204); padding-l=
eft: 1ex;"><div dir=3D"ltr"><div></div><div>During my time=C2=A0trying to i=
mplement the thread pool with C++, I found it unnecessary to store the &quo=
t;thread" objects or native handles in the thread pool, and blocking i=
n the destruction is=C2=A0meaningless. The code below is my minimum impleme=
ntation of the thread pool (for exposition; std::function<void()> cou=
ld be replaced by any polymorphic wrapper for the Callables), for your cons=
ideration:</div><div><br></div><div><div style=3D"border-width: 1px; border=
-style: solid; border-color: rgb(187, 187, 187); background-color: rgb(250,=
250, 250); word-wrap: break-word;"><code><div><font color=3D"#660066"><div=
>#include <mutex></div><div>#include <condition_variable></div>=
<div>#include <functional></div><div>#include <queue></div><div=
>#include <thread></div><div><br></div><div>class fixed_thread_pool {=
</div><div>=C2=A0public:</div><div>=C2=A0 explicit fixed_thread_pool(size_t=
thread_count)</div><div>=C2=A0 =C2=A0 =C2=A0 : data_(std::make_shared<d=
ata>()<wbr>) {</div><div>=C2=A0 =C2=A0 for (size_t i =3D 0; i < threa=
d_count; ++i) {</div><div>=C2=A0 =C2=A0 =C2=A0 std::thread([data =3D data_]=
{</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 std::unique_lock<std::mutex>=
lk(data->mtx_);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 for (;;) {</div><=
div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 if (!data->tasks_.empty()) {</div=
><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 auto current =3D std::move(=
data->tasks_.front()<wbr>);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0=
=C2=A0 data->tasks_.pop();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0=
=C2=A0 lk.unlock();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 cu=
rrent();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 lk.lock();</di=
v><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } else if (data->is_shutdown_)=
{</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 break;</div><div>=C2=
=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } else {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 data->cond_.wait(lk);</div><div>=C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 }</div><div>=C2=A0 =
=C2=A0 =C2=A0 }).detach();</div><div>=C2=A0 =C2=A0 }</div><div>=C2=A0 }</di=
v><div><br></div><div>=C2=A0 fixed_thread_pool() =3D default;</div><div>=C2=
=A0 fixed_thread_pool(fixed_<wbr>thread_pool&&) =3D default;</div><=
div><br></div><div>=C2=A0 ~fixed_thread_pool() {</div><div>=C2=A0 =C2=A0 if=
((bool) data_) {</div><div>=C2=A0 =C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =
=C2=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_->mtx_);</div><d=
iv>=C2=A0 =C2=A0 =C2=A0 =C2=A0 data_->is_shutdown_ =3D true;</div><div>=
=C2=A0 =C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 =C2=A0 data_->cond_.notif=
y_all();</div><div>=C2=A0 =C2=A0 }</div><div>=C2=A0 }</div><div><br></div><=
div>=C2=A0 template <class F></div><div>=C2=A0 void execute(F&&am=
p; task) {</div><div>=C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =C2=A0 std::lo=
ck_guard<std::mutex> lk(data_->mtx_);</div><div>=C2=A0 =C2=A0 =C2=
=A0 data_->tasks_.emplace(std::<wbr>forward<F>(task));</div><div>=
=C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 data_->cond_.notify_one();</div>=
<div>=C2=A0 }</div><div><br></div><div>=C2=A0private:</div><div>=C2=A0 stru=
ct data {</div><div>=C2=A0 =C2=A0 std::mutex mtx_;</div><div>=C2=A0 =C2=A0 =
std::condition_variable cond_;</div><div>=C2=A0 =C2=A0 bool is_shutdown_ =
=3D false;</div><div>=C2=A0 =C2=A0 std::queue<std::function<void(<wbr=
>)>> tasks_;</div><div>=C2=A0 };</div><div>=C2=A0 std::shared_ptr<=
data> data_;</div><div>};<br></div></font></div></code></div><br>Thank y=
ou for the reply!</div><div><br></div></div></blockquote><div><br></div><di=
v>That's under-performant because of the task queue being shared by all=
the threads.</div></div></div></blockquote><div><br></div><div>I would app=
reciate it if you could provide a better implementation and benchmark.</div=
><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0px 0px =
0px 0.8ex; border-left: 1px solid rgb(204, 204, 204); padding-left: 1ex;"><=
div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote=
" style=3D"margin: 0px 0px 0px 0.8ex; border-left: 1px solid rgb(204, 204, =
204); padding-left: 1ex;"><div dir=3D"ltr"><div></div><div>Mingxin Wang</di=
v></div><p></p>--=C2=A0<br>You received this message because you are subscr=
ibed to the Google Groups "ISO C++ Standard - Future Proposals" g=
roup.<br>To unsubscribe from this group and stop receiving emails from it, =
send an email to=C2=A0<a target=3D"_blank" gdf-obfuscated-mailto=3D"J5tlypk=
0BQAJ" rel=3D"nofollow" style=3D"color: rgb(102, 17, 204);">std-proposal...=
@<wbr>isocpp.org</a>.<br>To post to this group, send email to=C2=A0<a targe=
t=3D"_blank" gdf-obfuscated-mailto=3D"J5tlypk0BQAJ" rel=3D"nofollow" style=
=3D"color: rgb(102, 17, 204);">std-pr...@isocpp.org</a>.<br>To view this di=
scussion on the web visit=C2=A0<a href=3D"https://groups.google.com/a/isocp=
p.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.o=
rg?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank" rel=3D"nof=
ollow">https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposa=
ls/35f0c5a1-5d16-4bbf-<wbr>8783-07b3f38f84e0%40isocpp.org</a><wbr>.<br></bl=
ockquote><div><br></div></div></div></blockquote></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/d94c1947-531c-40e5-8f10-bc2b917c84a9%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/d94c1947-531c-40e5-8f10-bc2b917c84a9=
%40isocpp.org</a>.<br />
------=_Part_420_736532412.1522683614915--
------=_Part_419_996111149.1522683614914--
.
Author: "mysen via ISO C++ Standard - Future Proposals" <std-proposals@isocpp.org>
Date: Mon, 2 Apr 2018 11:19:47 -0700 (PDT)
Raw View
------=_Part_14961_1527992178.1522693187895
Content-Type: multipart/alternative;
boundary="----=_Part_14962_1045287405.1522693187896"
------=_Part_14962_1045287405.1522693187896
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Monday, April 2, 2018 at 8:40:15 AM UTC-7, Mingxin Wang wrote:
>
> On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=ABl Lamotte w=
rote:
>
>> On 2 April 2018 at 06:51, Mingxin Wang <wmx16...@163.com> wrote:
>>
>>>
>>> With my latest proposal about polymorphism (included in the=20
>>> attachments), we could design polymorphic modules with the new keyword=
=20
>>> "facade", e.g.:
>>>
>>> facade OnewayExecutor {
>>> void execute(static_proxy<Callable<void()>>) const;
>>> };
>>>
>>> ... and we are able to use it with proxies afterwards:
>>>
>>> static_proxy<OnewayExecutor> p0;
>>> static_proxy<OnewayExecutor&> p1;
>>> static_proxy<const OnewayExecutor&> p2;
>>> ...
>>>
>>> More detailes are included in the proposal, and I will appreciate it if=
=20
>>> there is any comment or feedback.
>>>
>>
>>
>> Although your proposal is interesting, this is only an implementation=20
>> detail of the polymorphic executors (which are already necessary in some=
=20
>> ways today) specification.
>> I don't know if your proposal is enough to implement these polymorphic=
=20
>> executors, but the specification only is concerned with the resulting=20
>> interface.
>>
>
> Built-in addresser template (aka. `static_proxy`) has similar interface=
=20
> with `std::any` in constructors and observers.
> =20
>
>> By the way, how would you specify a polymorphic executor using a=20
>> composition of several requirements (some might be custom), as the propo=
sal=20
>> requests?
>>
>
> The "facade" are compatible to the C++ type system, including but not=20
> limited to inheritance, overloading, templates, and qualifiers. For=20
> example, we are able to define a facade template `Callable` to replace th=
e=20
> class template `std::function`:
>
> template <class T>
> facade Callable; // undefined
>
> template <class R, class... Args>
> facade Callable<R(Args...)> {
> R operator(Args... args);
> };
>
> ... and we could define a series of facades for the executors:
>
> facade OneWayExecutor {
> void execute(static_proxy<Callable<void()>> f) const;
> };
>
> template <class T>
> facade TwoWayExecutor {
> std::experimental::future<T>=20
> twoway_execute(static_proxy<Callable<void()>> f) const;
> };
>
> ... and we can also define other facades based on them if necessary:
>
> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
> void wait_for_all_tasks_to_be_done_or_something();
> void reset_worker_count(std::size_t new_count);
> static std::string some_type_specific_description();
> };
>
> Providing there is a type `my_awesome_executor` meets the requirements=20
> defined by the facade, the following code shows its basic usage:
>
> const my_awesome_executor ex;
> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is not=
=20
> convertible to `non-const` reference;
> static_proxy<const MyExecutor&> p1(ex); // OK;
> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called;
> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructor=
=20
> is called;
> std::cout << p3.type() << std::endl; // OK; Print the result of=20
> `typeid(my_awesome_executor)`;
> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value is=
=20
> convertible to `const` reference;
> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;=20
> `non-volatile` value is convertible to `volatile` value;
> std::cout << p3.has_value() << std::endl; // OK; Print `false`, because=
=20
> the value has been moved to `p5`;
> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // OK;
> p5.execute([] { std::cout << "Although bad things happen sometimes..." <<=
=20
> std::endl; }); // Error; The `execute` function is not `volatile`;
>
>
I don't think that the facade concept is the problem so much as the=20
intention of the polymorphic wrapper -- which is intended to behave just=20
like any other executor. This means that the require semantics should work=
=20
properly to create an executor which satisfies all of the requirements of=
=20
the provided properties while also providing a type-agnostic wrapper. Also=
=20
of note is that the original caller should be able to know if their=20
executor fully satisfies the needs of a library to which it is passing the=
=20
executor.
I'm not totally clear what the static_proxy is doing in your suggestion,=20
but it is pretty important to be able to have a type which can describe the=
=20
set of properties which it can use with require() at compile time. Whether=
=20
that's internally implemented through facades is more of an implementer=20
decision, no?
=20
>>>
>>>> 4) Yes, it is minimal. The goal was never to specify a fully usable=20
>>>> thread pool - only that some minimal structure be provided such that=
=20
>>>> minimal executors can be defined. Trying to specify a perfect thread p=
ool,=20
>>>> assuming one to exist, would delay the executors specification for no =
gain.=20
>>>> =20
>>>>
>>>
>>> If it is a minimal one, I think it should not support "wait" or "stop"=
=20
>>> operations, and should be MoveConstructible. More importantly, the=20
>>> destructor should be non-blocking.
>>>
>>>
>> I don't think that's possible.
>> There is a need, in my experience, for an explicit synchronization point=
=20
>> with all the underlying threads to be able to make sense of the program.
>>
>
> I think that is what the users should concern about, not us. Users could=
=20
> use latches, futures or some other structural support utilities proposed =
in=20
> another paper of mine (P0642) to control the flow.
>
You can use latch-like or future-like objects for this purpose, but it's=20
the responsibility of the context to know when it's resources are shut=20
down, asking clients to be aware of the detail of how to track completion=
=20
of resources seems strange.
That said, there is a discussion going on about how to track groups of work=
=20
completing within an executor more generally so that you don't need every=
=20
executor (or really context) to support this at the level of "all work=20
running in the context" because that is overkill. That said, the hope is to=
=20
create a more generic facility for this purpose because it provides other=
=20
things like a communication channel to indicate when work needs to complete=
=20
(and potentially ways to complete that work through something like boost=20
blocking).
But going back to this scenario -- there is a ton of code that i've seen=20
which basically uses the thread pool as a bundle of work + execution and=20
the completion of execution exactly describes the completion of all that=20
work. You don't _have_ to do this, but it is a useful facility and=20
realistically, the resource does exist and someone is tracking that. Just a=
=20
question of whether there is a concrete object which does that. I'm not=20
clear what real simplicity benefit there is by removing this functionality.=
=20
Particularly because the role of the executor is to create the lightweight=
=20
stateless object, the context isn't intended to be passed around and=20
certainly not intended to be copied...
=20
> =20
>
>> For example in your following example, the tasks pushed in that thread=
=20
>> pool can survive the lifetime of the thread pool. That makes=20
>> reasoning almost impossible. To put it another way: it goes against RAII=
=20
>> principles and definitely is not the good way to go.
>>
>
> I do not understand how you come to the conclusion that "it goes against=
=20
> RAII principles". If my understanding is right, RAII is about "initializi=
ng=20
> the resource when it is acquired", and I did not find my code against thi=
s=20
> principle. Is there anything I missed?
>
> Actually, this implementation could be abused if one does not have the=20
> ability to write concurrent programs correctly. This phenomenon is common=
=20
> in the whole C++ programming language, not only at this point.
>
> Anyway, the proposal is not supposed to provide much in thread pools and=
=20
>> other proposals will provide these, in variety I suppose (or predict).
>>
>
> I will be grateful if you could provide any relevant information.
> =20
>
>> During my time trying to implement the thread pool with C++, I found it=
=20
>>> unnecessary to store the "thread" objects or native handles in the thre=
ad=20
>>> pool, and blocking in the destruction is meaningless. The code below is=
my=20
>>> minimum implementation of the thread pool (for exposition;=20
>>> std::function<void()> could be replaced by any polymorphic wrapper for =
the=20
>>> Callables), for your consideration:
>>>
>>> #include <mutex>
>>> #include <condition_variable>
>>> #include <functional>
>>> #include <queue>
>>> #include <thread>
>>>
>>> class fixed_thread_pool {
>>> public:
>>> explicit fixed_thread_pool(size_t thread_count)
>>> : data_(std::make_shared<data>()) {
>>> for (size_t i =3D 0; i < thread_count; ++i) {
>>> std::thread([data =3D data_] {
>>> std::unique_lock<std::mutex> lk(data->mtx_);
>>> for (;;) {
>>> if (!data->tasks_.empty()) {
>>> auto current =3D std::move(data->tasks_.front());
>>> data->tasks_.pop();
>>> lk.unlock();
>>> current();
>>> lk.lock();
>>> } else if (data->is_shutdown_) {
>>> break;
>>> } else {
>>> data->cond_.wait(lk);
>>> }
>>> }
>>> }).detach();
>>> }
>>> }
>>>
>>> fixed_thread_pool() =3D default;
>>> fixed_thread_pool(fixed_thread_pool&&) =3D default;
>>>
>>> ~fixed_thread_pool() {
>>> if ((bool) data_) {
>>> {
>>> std::lock_guard<std::mutex> lk(data_->mtx_);
>>> data_->is_shutdown_ =3D true;
>>> }
>>> data_->cond_.notify_all();
>>> }
>>> }
>>>
>>> template <class F>
>>> void execute(F&& task) {
>>> {
>>> std::lock_guard<std::mutex> lk(data_->mtx_);
>>> data_->tasks_.emplace(std::forward<F>(task));
>>> }
>>> data_->cond_.notify_one();
>>> }
>>>
>>> private:
>>> struct data {
>>> std::mutex mtx_;
>>> std::condition_variable cond_;
>>> bool is_shutdown_ =3D false;
>>> std::queue<std::function<void()>> tasks_;
>>> };
>>> std::shared_ptr<data> data_;
>>> };
>>>
>>> Thank you for the reply!
>>>
>>>
>> That's under-performant because of the task queue being shared by all th=
e=20
>> threads.
>>
>
> I would appreciate it if you could provide a better implementation and=20
> benchmark.
>
> Mingxin Wang
>>>
>>> --=20
>>> You received this message because you are subscribed to the Google=20
>>> Groups "ISO C++ Standard - Future Proposals" group.
>>> To unsubscribe from this group and stop receiving emails from it, send=
=20
>>> an email to std-proposal...@isocpp.org.
>>> To post to this group, send email to std-pr...@isocpp.org.
>>> To view this discussion on the web visit=20
>>> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5=
d16-4bbf-8783-07b3f38f84e0%40isocpp.org=20
>>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-=
5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=3Demail&utm_source=3Dfo=
oter>
>>> .
>>>
>>
>>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/e1aad245-9f02-4883-a2bb-4e5fc4f98638%40isocpp.or=
g.
------=_Part_14962_1045287405.1522693187896
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Monday, April 2, 2018 at 8:40:15 AM UTC-7, Ming=
xin Wang wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-=
left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr=
"><div>On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=ABl Lamo=
tte wrote:<br></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0=
px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div =
dir=3D"ltr"><div class=3D"gmail_quote">On 2 April 2018 at 06:51, Mingxin Wa=
ng=C2=A0<span dir=3D"ltr"><<a rel=3D"nofollow" style=3D"color:rgb(102,17=
,204)">wmx16...@163.com</a>></span>=C2=A0wrote:<br><blockquote class=3D"=
gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(20=
4,204,204);padding-left:1ex"><div dir=3D"ltr"><div><br></div><div>With my l=
atest proposal about polymorphism (included in the attachments), we could d=
esign polymorphic modules with the new keyword "facade", e.g.:</d=
iv><div><br></div><div><div style=3D"border-width:1px;border-style:solid;bo=
rder-color:rgb(187,187,187);background-color:rgb(250,250,250);word-wrap:bre=
ak-word"><code><div>facade OnewayExecutor {</div><div>=C2=A0 void execute(s=
tatic_proxy<Callable<<wbr>void()>>) const;</div><div>};</div></=
code></div><br>... and we are able to use it with proxies afterwards:</div>=
<div><br></div><div><div style=3D"border-width:1px;border-style:solid;borde=
r-color:rgb(187,187,187);background-color:rgb(250,250,250);word-wrap:break-=
word"><code><div>static_proxy<OnewayExecutor> p0;</div><div>static_pr=
oxy<OnewayExecutor&> p1;</div><div>static_proxy<const OnewayEx=
ecutor&> p2;</div><div>...</div></code></div><br>More detailes are i=
ncluded in the proposal, and=C2=A0I will appreciate it if there is any comm=
ent or feedback.</div><div></div></div></blockquote><div><br></div><div><br=
></div><div>Although your proposal is interesting, this is only an implemen=
tation detail of the polymorphic executors (which are already necessary in =
some ways today) specification.</div><div>I don't know if your proposal=
is enough to implement these polymorphic executors, but the specification =
only is concerned with the resulting interface.</div></div></div></blockquo=
te><div><br></div><div>Built-in addresser template (aka. `static_proxy`) ha=
s similar interface with `std::any` in constructors and observers.</div><di=
v>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px=
0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D=
"ltr"><div class=3D"gmail_quote">By the way, how would=C2=A0 you specify a =
polymorphic executor using a composition of several requirements (some migh=
t be custom), as the proposal requests?</div></div></blockquote><div><br></=
div><div>The "facade" are compatible to the C++ type system, incl=
uding but not limited to inheritance, overloading, templates, and qualifier=
s. For example, we are able to define a facade template `Callable` to repla=
ce the class template `std::function`:</div><div><br></div><div><div style=
=3D"border-width:1px;border-style:solid;border-color:rgb(187,187,187);backg=
round-color:rgb(250,250,250);word-wrap:break-word"><code><div><font color=
=3D"#660066"><div>template <class T></div><div>facade Callable; =C2=
=A0// undefined</div><div><br></div><div>template <class R, class... Arg=
s></div><div>facade Callable<R(Args...)> {</div><div>=C2=A0 R oper=
ator(Args... args);</div><div>};</div></font></div></code></div><br>... and=
we could define a series of facades for the executors:</div><div><br></div=
><div><div style=3D"border-width:1px;border-style:solid;border-color:rgb(18=
7,187,187);background-color:rgb(250,250,250);word-wrap:break-word"><code><d=
iv><font color=3D"#660066"><div>facade OneWayExecutor {</div><div>=C2=A0 vo=
id execute(static_proxy<Callable<<wbr>void()>> f) const;</div><=
div>};</div><div><br></div><div>template <class T></div><div>facade T=
woWayExecutor {</div><div>=C2=A0 std::experimental::future<T> twoway_=
execute(static_proxy<<wbr>Callable<void()>> f) const;</div><div=
>};</div></font></div></code></div><br>... and we can also define other fac=
ades based on them if necessary:</div><div><br></div><div><div style=3D"bor=
der-width:1px;border-style:solid;border-color:rgb(187,187,187);background-c=
olor:rgb(250,250,250);word-wrap:break-word"><code><div><div><div>facade MyE=
xecutor : OneWayExecutor, TwoWayExecutor {</div><div>=C2=A0 void wait_for_a=
ll_tasks_to_be_done_<wbr>or_something();</div><div>=C2=A0 void reset_worker=
_count(std::size_t new_count);</div><div>=C2=A0 static std::string some_typ=
e_specific_<wbr>description();</div><div>};</div></div></div></code></div><=
br>Providing there is a type `my_awesome_executor` meets the requirements d=
efined by the facade, the following code shows its basic usage:</div><div><=
br></div><div><div style=3D"background-color:rgb(250,250,250);border-color:=
rgb(187,187,187);border-style:solid;border-width:1px;word-wrap:break-word">=
<code><div><div>const my_awesome_executor ex;</div><div>static_proxy<MyE=
xecutor&> p0(ex); =C2=A0// Error; Because `const` value is not conve=
rtible to `non-const` reference;</div><div>static_proxy<const MyExecutor=
&> p1(ex); =C2=A0// OK;</div><div>static_proxy<MyExecutor> p2(=
ex); =C2=A0// OK; The copy-constructor is called;</div><div>static_proxy<=
;MyExecutor> p3(std::move(ex)); =C2=A0// OK; The move-constructor is cal=
led;</div><div>std::cout << p3.type() << std::endl; =C2=A0// OK=
; Print the result of `typeid(my_awesome_executor)`;</div><div>static_proxy=
<const OneWayExecutor&> p4(p2); =C2=A0// OK; `non-const` value is=
convertible to `const` reference;</div><div>static_proxy<volatile MyExe=
cutor> p5(std::move(p3)); =C2=A0// OK; `non-volatile` value is convertib=
le to `volatile` value;</div><div>std::cout << p3.has_value() <<=
; std::endl; =C2=A0// OK; Print `false`, because the value has been moved t=
o `p5`;</div><div>p4.execute([] { std::cout << "Life is so cool!=
" << std::endl; }); =C2=A0// OK;</div><div>p5.execute([] { std::=
cout << "Although bad things happen sometimes..." << =
std::endl; }); =C2=A0// Error; The `execute` function is not `volatile`;</d=
iv></div></code></div></div><div><br></div></div></blockquote><div><br></di=
v><div>I don't think that the facade concept is the problem so much as =
the intention of the polymorphic wrapper -- which is intended to behave jus=
t like any other executor. This means that the require semantics should wor=
k properly to create an executor which satisfies all of the requirements of=
the provided properties while also providing a type-agnostic wrapper. Also=
of note is that the original caller should be able to know if their execut=
or fully satisfies the needs of a library to which it is passing the execut=
or.</div><div><br></div><div>I'm not totally clear what the static_prox=
y is doing in your suggestion, but it is pretty important to be able to hav=
e a type which can describe the set of properties which it can use with req=
uire() at compile time. Whether that's internally implemented through f=
acades is more of an implementer decision, no?<br></div><div><br></div><div=
><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left=
: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><d=
iv></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8e=
x;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"=
><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"marg=
in:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1e=
x"><div dir=3D"ltr"><div>=C2=A0</div><blockquote class=3D"gmail_quote" styl=
e=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);paddin=
g-left:1ex"><div dir=3D"ltr">4) Yes, it is minimal. The goal was never to s=
pecify a fully usable thread pool - only that some minimal structure be pro=
vided such that minimal executors can be defined. Trying to specify a perfe=
ct thread pool, assuming one to exist, would delay the executors specificat=
ion for no gain. =C2=A0</div></blockquote><div><br></div><div>If it is a mi=
nimal one, I think it should not support "wait" or "stop&quo=
t; operations, and should be MoveConstructible. More importantly, the destr=
uctor should be non-blocking.</div><div><br></div></div></blockquote><div><=
br></div><div>I don't think that's possible.</div><div>There is a n=
eed, in my experience, for an explicit synchronization point with all the u=
nderlying threads to be able to make sense of the program.</div></div></div=
></blockquote><div><br></div><div>I think that is what the users should con=
cern about, not us. Users could use latches, futures or some other structur=
al support utilities proposed in another paper of mine (P0642) to control t=
he flow.</div></div></blockquote><div><br></div><div>You can use latch-like=
or future-like objects for this purpose, but it's the responsibility o=
f the context to know when it's resources are shut down, asking clients=
to be aware of the detail of how to track completion of resources seems st=
range.</div><div><br></div><div>That said, there is a discussion going on a=
bout how to track groups of work completing within an executor more general=
ly so that you don't need every executor (or really context) to support=
this at the level of "all work running in the context" because t=
hat is overkill. That said, the hope is to create a more generic facility f=
or this purpose because it provides other things like a communication chann=
el to indicate when work needs to complete (and potentially ways to complet=
e that work through something like boost blocking).</div><div><br></div><di=
v>But going back to this scenario -- there is a ton of code that i've s=
een which basically uses the thread pool as a bundle of work + execution an=
d the completion of execution exactly describes the completion of all that =
work. You don't _have_ to do this, but it is a useful facility and real=
istically, the resource does exist and someone is tracking that. Just a que=
stion of whether there is a concrete object which does that. I'm not cl=
ear what real simplicity benefit there is by removing this functionality. P=
articularly because the role of the executor is to create the lightweight s=
tateless object, the context isn't intended to be passed around and cer=
tainly not intended to be copied...</div><div>=C2=A0</div><blockquote class=
=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #cc=
c solid;padding-left: 1ex;"><div dir=3D"ltr"><div>=C2=A0</div><blockquote c=
lass=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px soli=
d rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_q=
uote"><div>For example in your following example, the tasks pushed in that =
thread pool can survive the lifetime of the thread pool. That makes=C2=A0</=
div><div>reasoning almost impossible. To put it another way: it goes agains=
t RAII principles and definitely is not the good way to go.</div></div></di=
v></blockquote><div><br></div><div>I do not understand how you come to the =
conclusion that "it goes against RAII principles". If my understa=
nding is right, RAII is about "initializing the resource when it is ac=
quired", and I did not find my code against this principle. Is there a=
nything I missed?</div><div><br></div><div>Actually, this implementation co=
uld be abused if one does not have the ability to write concurrent programs=
correctly. This=C2=A0phenomenon is common in the whole C++ programming lan=
guage, not only at this point.</div><div><br></div><blockquote class=3D"gma=
il_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,2=
04,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>=
Anyway, the proposal is not supposed to provide much in thread pools and ot=
her proposals will provide these, in variety I suppose (or predict).</div><=
/div></div></blockquote><div><br></div><div>I will be grateful if you could=
provide any relevant information.<br></div><div>=C2=A0</div><blockquote cl=
ass=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid=
rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_qu=
ote"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;bo=
rder-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><di=
v></div><div>During my time=C2=A0trying to implement the thread pool with C=
++, I found it unnecessary to store the "thread" objects or nativ=
e handles in the thread pool, and blocking in the destruction is=C2=A0meani=
ngless. The code below is my minimum implementation of the thread pool (for=
exposition; std::function<void()> could be replaced by any polymorph=
ic wrapper for the Callables), for your consideration:</div><div><br></div>=
<div><div style=3D"border-width:1px;border-style:solid;border-color:rgb(187=
,187,187);background-color:rgb(250,250,250);word-wrap:break-word"><code><di=
v><font color=3D"#660066"><div>#include <mutex></div><div>#include &l=
t;condition_variable></div><div>#include <functional></div><div>#i=
nclude <queue></div><div>#include <thread></div><div><br></div>=
<div>class fixed_thread_pool {</div><div>=C2=A0public:</div><div>=C2=A0 exp=
licit fixed_thread_pool(size_t thread_count)</div><div>=C2=A0 =C2=A0 =C2=A0=
: data_(std::make_shared<data>()<wbr>) {</div><div>=C2=A0 =C2=A0 for=
(size_t i =3D 0; i < thread_count; ++i) {</div><div>=C2=A0 =C2=A0 =C2=
=A0 std::thread([data =3D data_] {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 st=
d::unique_lock<std::mutex> lk(data->mtx_);</div><div>=C2=A0 =C2=A0=
=C2=A0 =C2=A0 for (;;) {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 if (=
!data->tasks_.empty()) {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0 auto current =3D std::move(data->tasks_.front()<wbr>);</div><div>=
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 data->tasks_.pop();</div><div>=
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 lk.unlock();</div><div>=C2=A0 =C2=
=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 current();</div><div>=C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 =C2=A0 lk.lock();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 } else if (data->is_shutdown_) {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 =C2=A0 break;</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } els=
e {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 data->cond_.wait=
(lk);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=
=A0 =C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 =C2=A0 }).detach();</div><div>=
=C2=A0 =C2=A0 }</div><div>=C2=A0 }</div><div><br></div><div>=C2=A0 fixed_th=
read_pool() =3D default;</div><div>=C2=A0 fixed_thread_pool(fixed_<wbr>thre=
ad_pool&&) =3D default;</div><div><br></div><div>=C2=A0 ~fixed_thre=
ad_pool() {</div><div>=C2=A0 =C2=A0 if ((bool) data_) {</div><div>=C2=A0 =
=C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 std::lock_guard<st=
d::mutex> lk(data_->mtx_);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 data=
_->is_shutdown_ =3D true;</div><div>=C2=A0 =C2=A0 =C2=A0 }</div><div>=C2=
=A0 =C2=A0 =C2=A0 data_->cond_.notify_all();</div><div>=C2=A0 =C2=A0 }</=
div><div>=C2=A0 }</div><div><br></div><div>=C2=A0 template <class F><=
/div><div>=C2=A0 void execute(F&& task) {</div><div>=C2=A0 =C2=A0 {=
</div><div>=C2=A0 =C2=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_-=
>mtx_);</div><div>=C2=A0 =C2=A0 =C2=A0 data_->tasks_.emplace(std::<wb=
r>forward<F>(task));</div><div>=C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=
=A0 data_->cond_.notify_one();</div><div>=C2=A0 }</div><div><br></div><d=
iv>=C2=A0private:</div><div>=C2=A0 struct data {</div><div>=C2=A0 =C2=A0 st=
d::mutex mtx_;</div><div>=C2=A0 =C2=A0 std::condition_variable cond_;</div>=
<div>=C2=A0 =C2=A0 bool is_shutdown_ =3D false;</div><div>=C2=A0 =C2=A0 std=
::queue<std::function<void(<wbr>)>> tasks_;</div><div>=C2=A0 };=
</div><div>=C2=A0 std::shared_ptr<data> data_;</div><div>};<br></div>=
</font></div></code></div><br>Thank you for the reply!</div><div><br></div>=
</div></blockquote><div><br></div><div>That's under-performant because =
of the task queue being shared by all the threads.</div></div></div></block=
quote><div><br></div><div>I would appreciate it if you could provide a bett=
er implementation and benchmark.</div><div><br></div><blockquote class=3D"g=
mail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204=
,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><bl=
ockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-lef=
t:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div></div>=
<div>Mingxin Wang</div></div><p></p>--=C2=A0<br>You received this message b=
ecause you are subscribed to the Google Groups "ISO C++ Standard - Fut=
ure Proposals" group.<br>To unsubscribe from this group and stop recei=
ving emails from it, send an email to=C2=A0<a rel=3D"nofollow" style=3D"col=
or:rgb(102,17,204)">std-proposal...@isocpp.org</a>.<br>To post to this grou=
p, send email to=C2=A0<a rel=3D"nofollow" style=3D"color:rgb(102,17,204)">s=
td-pr...@isocpp.org</a>.<br>To view this discussion on the web visit=C2=A0<=
a href=3D"https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0=
c5a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=3Demail&utm_so=
urce=3Dfooter" rel=3D"nofollow" target=3D"_blank" onmousedown=3D"this.href=
=3D'https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5=
a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium\x3demail\x26utm_sour=
ce\x3dfooter';return true;" onclick=3D"this.href=3D'https://groups.=
google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-8783-07b3f=
38f84e0%40isocpp.org?utm_medium\x3demail\x26utm_source\x3dfooter';retur=
n true;">https://groups.google.<wbr>com/a/isocpp.org/d/msgid/std-<wbr>propo=
sals/35f0c5a1-5d16-4bbf-<wbr>8783-07b3f38f84e0%40isocpp.org</a><wbr>.<br></=
blockquote><div><br></div></div></div></blockquote></div></blockquote></div=
>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/e1aad245-9f02-4883-a2bb-4e5fc4f98638%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/e1aad245-9f02-4883-a2bb-4e5fc4f98638=
%40isocpp.org</a>.<br />
------=_Part_14962_1045287405.1522693187896--
------=_Part_14961_1527992178.1522693187895--
.
Author: Lee Howes <xrikcus@gmail.com>
Date: Mon, 2 Apr 2018 11:58:09 -0700
Raw View
--000000000000c414e60568e22bde
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
> Why do we need multi-dimensional iteration? Could you provide a
meaningful use case where it would help in performance?
for(each block in row) {
for(each block in column) {
perform DCT on image block
}
}
or any number of algorithms applied to an image or similar data structure.
Take a look at any CUDA code for examples. When hardware provides a 2-D
iterator, you might as well give access to it.
If the row size is prime, then implementing this using a 1D loop is going
to include a nasty mod, which would end up running thousands of times in
each GPU work item. Pretty inefficient in general.
On 2 April 2018 at 08:40, Mingxin Wang <wmx16835vv@163.com> wrote:
> On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=ABl Lamotte w=
rote:
>
>> On 2 April 2018 at 06:51, Mingxin Wang <wmx16...@163.com> wrote:
>>
>>>
>>> With my latest proposal about polymorphism (included in the
>>> attachments), we could design polymorphic modules with the new keyword
>>> "facade", e.g.:
>>>
>>> facade OnewayExecutor {
>>> void execute(static_proxy<Callable<void()>>) const;
>>> };
>>>
>>> ... and we are able to use it with proxies afterwards:
>>>
>>> static_proxy<OnewayExecutor> p0;
>>> static_proxy<OnewayExecutor&> p1;
>>> static_proxy<const OnewayExecutor&> p2;
>>> ...
>>>
>>> More detailes are included in the proposal, and I will appreciate it if
>>> there is any comment or feedback.
>>>
>>
>>
>> Although your proposal is interesting, this is only an implementation
>> detail of the polymorphic executors (which are already necessary in some
>> ways today) specification.
>> I don't know if your proposal is enough to implement these polymorphic
>> executors, but the specification only is concerned with the resulting
>> interface.
>>
>
> Built-in addresser template (aka. `static_proxy`) has similar interface
> with `std::any` in constructors and observers.
>
>
>> By the way, how would you specify a polymorphic executor using a
>> composition of several requirements (some might be custom), as the propo=
sal
>> requests?
>>
>
> The "facade" are compatible to the C++ type system, including but not
> limited to inheritance, overloading, templates, and qualifiers. For
> example, we are able to define a facade template `Callable` to replace th=
e
> class template `std::function`:
>
> template <class T>
> facade Callable; // undefined
>
> template <class R, class... Args>
> facade Callable<R(Args...)> {
> R operator(Args... args);
> };
>
> ... and we could define a series of facades for the executors:
>
> facade OneWayExecutor {
> void execute(static_proxy<Callable<void()>> f) const;
> };
>
> template <class T>
> facade TwoWayExecutor {
> std::experimental::future<T> twoway_execute(static_proxy<Callable<void(=
)>>
> f) const;
> };
>
> ... and we can also define other facades based on them if necessary:
>
> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
> void wait_for_all_tasks_to_be_done_or_something();
> void reset_worker_count(std::size_t new_count);
> static std::string some_type_specific_description();
> };
>
> Providing there is a type `my_awesome_executor` meets the requirements
> defined by the facade, the following code shows its basic usage:
>
> const my_awesome_executor ex;
> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is not
> convertible to `non-const` reference;
> static_proxy<const MyExecutor&> p1(ex); // OK;
> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called;
> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructor
> is called;
> std::cout << p3.type() << std::endl; // OK; Print the result of
> `typeid(my_awesome_executor)`;
> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value is
> convertible to `const` reference;
> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;
> `non-volatile` value is convertible to `volatile` value;
> std::cout << p3.has_value() << std::endl; // OK; Print `false`, because
> the value has been moved to `p5`;
> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // OK;
> p5.execute([] { std::cout << "Although bad things happen sometimes..." <<
> std::endl; }); // Error; The `execute` function is not `volatile`;
>
>
>>>
>>>> 4) Yes, it is minimal. The goal was never to specify a fully usable
>>>> thread pool - only that some minimal structure be provided such that
>>>> minimal executors can be defined. Trying to specify a perfect thread p=
ool,
>>>> assuming one to exist, would delay the executors specification for no =
gain.
>>>>
>>>>
>>>
>>> If it is a minimal one, I think it should not support "wait" or "stop"
>>> operations, and should be MoveConstructible. More importantly, the
>>> destructor should be non-blocking.
>>>
>>>
>> I don't think that's possible.
>> There is a need, in my experience, for an explicit synchronization point
>> with all the underlying threads to be able to make sense of the program.
>>
>
> I think that is what the users should concern about, not us. Users could
> use latches, futures or some other structural support utilities proposed =
in
> another paper of mine (P0642) to control the flow.
>
>
>> For example in your following example, the tasks pushed in that thread
>> pool can survive the lifetime of the thread pool. That makes
>> reasoning almost impossible. To put it another way: it goes against RAII
>> principles and definitely is not the good way to go.
>>
>
> I do not understand how you come to the conclusion that "it goes against
> RAII principles". If my understanding is right, RAII is about "initializi=
ng
> the resource when it is acquired", and I did not find my code against thi=
s
> principle. Is there anything I missed?
>
> Actually, this implementation could be abused if one does not have the
> ability to write concurrent programs correctly. This phenomenon is common
> in the whole C++ programming language, not only at this point.
>
> Anyway, the proposal is not supposed to provide much in thread pools and
>> other proposals will provide these, in variety I suppose (or predict).
>>
>
> I will be grateful if you could provide any relevant information.
>
>
>> During my time trying to implement the thread pool with C++, I found it
>>> unnecessary to store the "thread" objects or native handles in the thre=
ad
>>> pool, and blocking in the destruction is meaningless. The code below is=
my
>>> minimum implementation of the thread pool (for exposition;
>>> std::function<void()> could be replaced by any polymorphic wrapper for =
the
>>> Callables), for your consideration:
>>>
>>> #include <mutex>
>>> #include <condition_variable>
>>> #include <functional>
>>> #include <queue>
>>> #include <thread>
>>>
>>> class fixed_thread_pool {
>>> public:
>>> explicit fixed_thread_pool(size_t thread_count)
>>> : data_(std::make_shared<data>()) {
>>> for (size_t i =3D 0; i < thread_count; ++i) {
>>> std::thread([data =3D data_] {
>>> std::unique_lock<std::mutex> lk(data->mtx_);
>>> for (;;) {
>>> if (!data->tasks_.empty()) {
>>> auto current =3D std::move(data->tasks_.front());
>>> data->tasks_.pop();
>>> lk.unlock();
>>> current();
>>> lk.lock();
>>> } else if (data->is_shutdown_) {
>>> break;
>>> } else {
>>> data->cond_.wait(lk);
>>> }
>>> }
>>> }).detach();
>>> }
>>> }
>>>
>>> fixed_thread_pool() =3D default;
>>> fixed_thread_pool(fixed_thread_pool&&) =3D default;
>>>
>>> ~fixed_thread_pool() {
>>> if ((bool) data_) {
>>> {
>>> std::lock_guard<std::mutex> lk(data_->mtx_);
>>> data_->is_shutdown_ =3D true;
>>> }
>>> data_->cond_.notify_all();
>>> }
>>> }
>>>
>>> template <class F>
>>> void execute(F&& task) {
>>> {
>>> std::lock_guard<std::mutex> lk(data_->mtx_);
>>> data_->tasks_.emplace(std::forward<F>(task));
>>> }
>>> data_->cond_.notify_one();
>>> }
>>>
>>> private:
>>> struct data {
>>> std::mutex mtx_;
>>> std::condition_variable cond_;
>>> bool is_shutdown_ =3D false;
>>> std::queue<std::function<void()>> tasks_;
>>> };
>>> std::shared_ptr<data> data_;
>>> };
>>>
>>> Thank you for the reply!
>>>
>>>
>> That's under-performant because of the task queue being shared by all th=
e
>> threads.
>>
>
> I would appreciate it if you could provide a better implementation and
> benchmark.
>
> Mingxin Wang
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "ISO C++ Standard - Future Proposals" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to std-proposal...@isocpp.org.
>>> To post to this group, send email to std-pr...@isocpp.org.
>>> To view this discussion on the web visit https://groups.google.
>>> com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-87
>>> 83-07b3f38f84e0%40isocpp.org
>>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-=
5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=3Demail&utm_source=3Dfo=
oter>
>>> .
>>>
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/d94c1947-531c-40e5-
> 8f10-bc2b917c84a9%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/d94c1947-53=
1c-40e5-8f10-bc2b917c84a9%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoot=
er>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAJH_FNVW2muiXziz2ef%2BXwTeFwGQYYDfWd8Uth9eiy8U4=
YqpTg%40mail.gmail.com.
--000000000000c414e60568e22bde
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">>=C2=A0<span style=3D"color:rgb(34,34,34);font-family:a=
rial,sans-serif;font-size:12.8px;font-style:normal;font-variant-ligatures:n=
ormal;font-variant-caps:normal;font-weight:400;letter-spacing:normal;text-a=
lign:start;text-indent:0px;text-transform:none;white-space:normal;word-spac=
ing:0px;background-color:rgb(255,255,255);text-decoration-style:initial;tex=
t-decoration-color:initial;float:none;display:inline">Why do we need multi-=
dimensional iteration? Could you provide a meaningful use case where it wou=
ld help in performance?</span><div><span style=3D"color:rgb(34,34,34);font-=
family:arial,sans-serif;font-size:12.8px;font-style:normal;font-variant-lig=
atures:normal;font-variant-caps:normal;font-weight:400;letter-spacing:norma=
l;text-align:start;text-indent:0px;text-transform:none;white-space:normal;w=
ord-spacing:0px;background-color:rgb(255,255,255);text-decoration-style:ini=
tial;text-decoration-color:initial;float:none;display:inline"><br></span></=
div><div><span style=3D"color:rgb(34,34,34);font-family:arial,sans-serif;fo=
nt-size:12.8px;font-style:normal;font-variant-ligatures:normal;font-variant=
-caps:normal;font-weight:400;letter-spacing:normal;text-align:start;text-in=
dent:0px;text-transform:none;white-space:normal;word-spacing:0px;background=
-color:rgb(255,255,255);text-decoration-style:initial;text-decoration-color=
:initial;float:none;display:inline">for(each block in row) {</span></div><d=
iv><span style=3D"color:rgb(34,34,34);font-family:arial,sans-serif;font-siz=
e:12.8px;font-style:normal;font-variant-ligatures:normal;font-variant-caps:=
normal;font-weight:400;letter-spacing:normal;text-align:start;text-indent:0=
px;text-transform:none;white-space:normal;word-spacing:0px;background-color=
:rgb(255,255,255);text-decoration-style:initial;text-decoration-color:initi=
al;float:none;display:inline">=C2=A0 for(each block in column) {</span></di=
v><div><span style=3D"color:rgb(34,34,34);font-family:arial,sans-serif;font=
-size:12.8px;font-style:normal;font-variant-ligatures:normal;font-variant-c=
aps:normal;font-weight:400;letter-spacing:normal;text-align:start;text-inde=
nt:0px;text-transform:none;white-space:normal;word-spacing:0px;background-c=
olor:rgb(255,255,255);text-decoration-style:initial;text-decoration-color:i=
nitial;float:none;display:inline">=C2=A0 =C2=A0 perform DCT on image block<=
/span></div><div><span style=3D"font-size:12.8px">=C2=A0 }</span></div><div=
><span style=3D"font-size:12.8px">}</span></div><div><span style=3D"font-si=
ze:12.8px"><br></span></div><div><span style=3D"font-size:12.8px">or any nu=
mber of algorithms applied to an image or similar data structure. Take a lo=
ok at any CUDA code for examples. When hardware provides a 2-D iterator, yo=
u might as well give access to it.</span></div><div><span style=3D"font-siz=
e:12.8px"><br></span></div><div><span style=3D"font-size:12.8px">If the row=
size is prime, then implementing this using a 1D loop is going to include =
a nasty mod, which would end up running thousands of times in each GPU work=
item. Pretty inefficient in general.</span></div><div><span style=3D"color=
:rgb(34,34,34);font-family:arial,sans-serif;font-size:12.8px;font-style:nor=
mal;font-variant-ligatures:normal;font-variant-caps:normal;font-weight:400;=
letter-spacing:normal;text-align:start;text-indent:0px;text-transform:none;=
white-space:normal;word-spacing:0px;background-color:rgb(255,255,255);text-=
decoration-style:initial;text-decoration-color:initial;float:none;display:i=
nline">=C2=A0=C2=A0</span></div></div><div class=3D"gmail_extra"><br><div c=
lass=3D"gmail_quote">On 2 April 2018 at 08:40, Mingxin Wang <span dir=3D"lt=
r"><<a href=3D"mailto:wmx16835vv@163.com" target=3D"_blank">wmx16835vv@1=
63.com</a>></span> wrote:<br><blockquote class=3D"gmail_quote" style=3D"=
margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"=
ltr"><div>On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=ABl L=
amotte wrote:<br></div><span class=3D""><blockquote class=3D"gmail_quote" s=
tyle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);pad=
ding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote">On 2 April 2018 =
at 06:51, Mingxin Wang=C2=A0<span dir=3D"ltr"><<a rel=3D"nofollow" style=
=3D"color:rgb(102,17,204)">wmx16...@163.com</a>></span>=C2=A0wrote:<br><=
blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-l=
eft:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div><br>=
</div><div>With my latest proposal about polymorphism (included in the atta=
chments), we could design polymorphic modules with the new keyword "fa=
cade", e.g.:</div><div><br></div><div><div style=3D"border-width:1px;b=
order-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,25=
0,250);word-wrap:break-word"><code><div>facade OnewayExecutor {</div><div>=
=C2=A0 void execute(static_proxy<Callable<<wbr>void()>>) const;=
</div><div>};</div></code></div><br>... and we are able to use it with prox=
ies afterwards:</div><div><br></div><div><div style=3D"border-width:1px;bor=
der-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,250,=
250);word-wrap:break-word"><code><div>static_proxy<OnewayExecutor> p0=
;</div><div>static_proxy<OnewayExecutor&> p1;</div><div>static_pr=
oxy<const OnewayExecutor&> p2;</div><div>...</div></code></div><b=
r>More detailes are included in the proposal, and=C2=A0I will appreciate it=
if there is any comment or feedback.</div><div></div></div></blockquote><d=
iv><br></div><div><br></div><div>Although your proposal is interesting, thi=
s is only an implementation detail of the polymorphic executors (which are =
already necessary in some ways today) specification.</div><div>I don't =
know if your proposal is enough to implement these polymorphic executors, b=
ut the specification only is concerned with the resulting interface.</div><=
/div></div></blockquote><div><br></div></span><div>Built-in addresser templ=
ate (aka. `static_proxy`) has similar interface with `std::any` in construc=
tors and observers.</div><span class=3D""><div>=C2=A0</div><blockquote clas=
s=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid r=
gb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quot=
e">By the way, how would=C2=A0 you specify a polymorphic executor using a c=
omposition of several requirements (some might be custom), as the proposal =
requests?</div></div></blockquote><div><br></div></span><div>The "faca=
de" are compatible to the C++ type system, including but not limited t=
o inheritance, overloading, templates, and qualifiers. For example, we are =
able to define a facade template `Callable` to replace the class template `=
std::function`:</div><div><br></div><div><div class=3D"m_33013627005241568p=
rettyprint" style=3D"border-width:1px;border-style:solid;border-color:rgb(1=
87,187,187);background-color:rgb(250,250,250);word-wrap:break-word"><code c=
lass=3D"m_33013627005241568prettyprint"><div class=3D"m_33013627005241568su=
bprettyprint"><font color=3D"#660066"><div class=3D"m_33013627005241568subp=
rettyprint">template <class T></div><div class=3D"m_33013627005241568=
subprettyprint">facade Callable; =C2=A0// undefined</div><div class=3D"m_33=
013627005241568subprettyprint"><br></div><div class=3D"m_33013627005241568s=
ubprettyprint">template <class R, class... Args></div><div class=3D"m=
_33013627005241568subprettyprint">facade Callable<R(Args...)> {</div>=
<div class=3D"m_33013627005241568subprettyprint">=C2=A0 R operator(Args... =
args);</div><div class=3D"m_33013627005241568subprettyprint">};</div></font=
></div></code></div><br>... and we could define a series of facades for the=
executors:</div><div><br></div><div><div class=3D"m_33013627005241568prett=
yprint" style=3D"border-width:1px;border-style:solid;border-color:rgb(187,1=
87,187);background-color:rgb(250,250,250);word-wrap:break-word"><code class=
=3D"m_33013627005241568prettyprint"><div class=3D"m_33013627005241568subpre=
ttyprint"><font color=3D"#660066"><div class=3D"m_33013627005241568subprett=
yprint">facade OneWayExecutor {</div><div class=3D"m_33013627005241568subpr=
ettyprint">=C2=A0 void execute(static_proxy<Callable<<wbr>void()>&=
gt; f) const;</div><div class=3D"m_33013627005241568subprettyprint">};</div=
><div class=3D"m_33013627005241568subprettyprint"><br></div><div class=3D"m=
_33013627005241568subprettyprint">template <class T></div><div class=
=3D"m_33013627005241568subprettyprint">facade TwoWayExecutor {</div><div cl=
ass=3D"m_33013627005241568subprettyprint">=C2=A0 std::experimental::future&=
lt;T> twoway_execute(static_proxy<<wbr>Callable<void()>> f) =
const;</div><div class=3D"m_33013627005241568subprettyprint">};</div></font=
></div></code></div><br>... and we can also define other facades based on t=
hem if necessary:</div><div><br></div><div><div class=3D"m_3301362700524156=
8prettyprint" style=3D"border-width:1px;border-style:solid;border-color:rgb=
(187,187,187);background-color:rgb(250,250,250);word-wrap:break-word"><code=
class=3D"m_33013627005241568prettyprint"><div class=3D"m_33013627005241568=
subprettyprint"><div class=3D"m_33013627005241568subprettyprint"><div class=
=3D"m_33013627005241568subprettyprint">facade MyExecutor : OneWayExecutor, =
TwoWayExecutor {</div><div class=3D"m_33013627005241568subprettyprint">=C2=
=A0 void wait_for_all_tasks_to_be_done_<wbr>or_something();</div><div class=
=3D"m_33013627005241568subprettyprint">=C2=A0 void reset_worker_count(std::=
size_t new_count);</div><div class=3D"m_33013627005241568subprettyprint">=
=C2=A0 static std::string some_type_specific_<wbr>description();</div><div =
class=3D"m_33013627005241568subprettyprint">};</div></div></div></code></di=
v><br>Providing there is a type `my_awesome_executor` meets the requirement=
s defined by the facade, the following code shows its basic usage:</div><di=
v><br></div><div><div class=3D"m_33013627005241568prettyprint" style=3D"bac=
kground-color:rgb(250,250,250);border-color:rgb(187,187,187);border-style:s=
olid;border-width:1px;word-wrap:break-word"><code class=3D"m_33013627005241=
568prettyprint"><div class=3D"m_33013627005241568subprettyprint"><div class=
=3D"m_33013627005241568subprettyprint">const my_awesome_executor ex;</div><=
div class=3D"m_33013627005241568subprettyprint">static_proxy<MyExecutor&=
amp;> p0(ex); =C2=A0// Error; Because `const` value is not convertible t=
o `non-const` reference;</div><div class=3D"m_33013627005241568subprettypri=
nt">static_proxy<const MyExecutor&> p1(ex); =C2=A0// OK;</div><di=
v class=3D"m_33013627005241568subprettyprint">static_proxy<MyExecutor>=
; p2(ex); =C2=A0// OK; The copy-constructor is called;</div><div class=3D"m=
_33013627005241568subprettyprint">static_proxy<MyExecutor> p3(std::mo=
ve(ex)); =C2=A0// OK; The move-constructor is called;</div><div class=3D"m_=
33013627005241568subprettyprint">std::cout << p3.type() << std:=
:endl; =C2=A0// OK; Print the result of `typeid(my_awesome_executor)`;</div=
><div class=3D"m_33013627005241568subprettyprint">static_proxy<const One=
WayExecutor&> p4(p2); =C2=A0// OK; `non-const` value is convertible =
to `const` reference;</div><div class=3D"m_33013627005241568subprettyprint"=
>static_proxy<volatile MyExecutor> p5(std::move(p3)); =C2=A0// OK; `n=
on-volatile` value is convertible to `volatile` value;</div><div class=3D"m=
_33013627005241568subprettyprint">std::cout << p3.has_value() <<=
; std::endl; =C2=A0// OK; Print `false`, because the value has been moved t=
o `p5`;</div><div class=3D"m_33013627005241568subprettyprint">p4.execute([]=
{ std::cout << "Life is so cool!" << std::endl; }); =
=C2=A0// OK;</div><div class=3D"m_33013627005241568subprettyprint">p5.execu=
te([] { std::cout << "Although bad things happen sometimes...&qu=
ot; << std::endl; }); =C2=A0// Error; The `execute` function is not `=
volatile`;</div></div></code></div></div><span class=3D""><div><br></div><b=
lockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-le=
ft:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=
=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px =
0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=
=3D"ltr"><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin=
:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"=
><div dir=3D"ltr">4) Yes, it is minimal. The goal was never to specify a fu=
lly usable thread pool - only that some minimal structure be provided such =
that minimal executors can be defined. Trying to specify a perfect thread p=
ool, assuming one to exist, would delay the executors specification for no =
gain. =C2=A0</div></blockquote><div><br></div><div>If it is a minimal one, =
I think it should not support "wait" or "stop" operatio=
ns, and should be MoveConstructible. More importantly, the destructor shoul=
d be non-blocking.</div><div><br></div></div></blockquote><div><br></div><d=
iv>I don't think that's possible.</div><div>There is a need, in my =
experience, for an explicit synchronization point with all the underlying t=
hreads to be able to make sense of the program.</div></div></div></blockquo=
te><div><br></div></span><div>I think that is what the users should concern=
about, not us. Users could use latches, futures or some other structural s=
upport utilities proposed in another paper of mine (P0642) to control the f=
low.</div><span class=3D""><div>=C2=A0</div><blockquote class=3D"gmail_quot=
e" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204)=
;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>For exa=
mple in your following example, the tasks pushed in that thread pool can su=
rvive the lifetime of the thread pool. That makes=C2=A0</div><div>reasoning=
almost impossible. To put it another way: it goes against RAII principles =
and definitely is not the good way to go.</div></div></div></blockquote><di=
v><br></div></span><div>I do not understand how you come to the conclusion =
that "it goes against RAII principles". If my understanding is ri=
ght, RAII is about "initializing the resource when it is acquired"=
;, and I did not find my code against this principle. Is there anything I m=
issed?</div><div><br></div><div>Actually, this implementation could be abus=
ed if one does not have the ability to write concurrent programs correctly.=
This=C2=A0phenomenon is common in the whole C++ programming language, not =
only at this point.</div><span class=3D""><div><br></div><blockquote class=
=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rg=
b(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote=
"><div>Anyway, the proposal is not supposed to provide much in thread pools=
and other proposals will provide these, in variety I suppose (or predict).=
</div></div></div></blockquote><div><br></div></span><div>I will be gratefu=
l if you could provide any relevant information.<br></div><div><div class=
=3D"h5"><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:=
0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">=
<div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quot=
e" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204)=
;padding-left:1ex"><div dir=3D"ltr"><div></div><div>During my time=C2=A0try=
ing to implement the thread pool with C++, I found it unnecessary to store =
the "thread" objects or native handles in the thread pool, and bl=
ocking in the destruction is=C2=A0meaningless. The code below is my minimum=
implementation of the thread pool (for exposition; std::function<void()=
> could be replaced by any polymorphic wrapper for the Callables), for y=
our consideration:</div><div><br></div><div><div style=3D"border-width:1px;=
border-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,2=
50,250);word-wrap:break-word"><code><div><font color=3D"#660066"><div>#incl=
ude <mutex></div><div>#include <condition_variable></div><div>#=
include <functional></div><div>#include <queue></div><div>#incl=
ude <thread></div><div><br></div><div>class fixed_thread_pool {</div>=
<div>=C2=A0public:</div><div>=C2=A0 explicit fixed_thread_pool(size_t threa=
d_count)</div><div>=C2=A0 =C2=A0 =C2=A0 : data_(std::make_shared<data>=
;()<wbr>) {</div><div>=C2=A0 =C2=A0 for (size_t i =3D 0; i < thread_coun=
t; ++i) {</div><div>=C2=A0 =C2=A0 =C2=A0 std::thread([data =3D data_] {</di=
v><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 std::unique_lock<std::mutex> lk(da=
ta->mtx_);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 for (;;) {</div><div>=
=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 if (!data->tasks_.empty()) {</div><di=
v>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 auto current =3D std::move(data=
->tasks_.front()<wbr>);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 data->tasks_.pop();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=
=A0 lk.unlock();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 curren=
t();</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 lk.lock();</div><d=
iv>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 } else if (data->is_shutdown_) {</=
div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 =C2=A0 break;</div><div>=C2=A0 =
=C2=A0 =C2=A0 =C2=A0 =C2=A0 } else {</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 =
=C2=A0 =C2=A0 data->cond_.wait(lk);</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=
=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 =C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=
=A0 =C2=A0 }).detach();</div><div>=C2=A0 =C2=A0 }</div><div>=C2=A0 }</div><=
div><br></div><div>=C2=A0 fixed_thread_pool() =3D default;</div><div>=C2=A0=
fixed_thread_pool(fixed_thread<wbr>_pool&&) =3D default;</div><div=
><br></div><div>=C2=A0 ~fixed_thread_pool() {</div><div>=C2=A0 =C2=A0 if ((=
bool) data_) {</div><div>=C2=A0 =C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =C2=
=A0 =C2=A0 std::lock_guard<std::mutex> lk(data_->mtx_);</div><div>=
=C2=A0 =C2=A0 =C2=A0 =C2=A0 data_->is_shutdown_ =3D true;</div><div>=C2=
=A0 =C2=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 =C2=A0 data_->cond_.notify_a=
ll();</div><div>=C2=A0 =C2=A0 }</div><div>=C2=A0 }</div><div><br></div><div=
>=C2=A0 template <class F></div><div>=C2=A0 void execute(F&& =
task) {</div><div>=C2=A0 =C2=A0 {</div><div>=C2=A0 =C2=A0 =C2=A0 std::lock_=
guard<std::mutex> lk(data_->mtx_);</div><div>=C2=A0 =C2=A0 =C2=A0 =
data_->tasks_.emplace(std::for<wbr>ward<F>(task));</div><div>=C2=
=A0 =C2=A0 }</div><div>=C2=A0 =C2=A0 data_->cond_.notify_one();</div><di=
v>=C2=A0 }</div><div><br></div><div>=C2=A0private:</div><div>=C2=A0 struct =
data {</div><div>=C2=A0 =C2=A0 std::mutex mtx_;</div><div>=C2=A0 =C2=A0 std=
::condition_variable cond_;</div><div>=C2=A0 =C2=A0 bool is_shutdown_ =3D f=
alse;</div><div>=C2=A0 =C2=A0 std::queue<std::function<void(<wbr>)>=
;> tasks_;</div><div>=C2=A0 };</div><div>=C2=A0 std::shared_ptr<data&=
gt; data_;</div><div>};<br></div></font></div></code></div><br>Thank you fo=
r the reply!</div><div><br></div></div></blockquote><div><br></div><div>Tha=
t's under-performant because of the task queue being shared by all the =
threads.</div></div></div></blockquote><div><br></div></div></div><div>I wo=
uld appreciate it if you could provide a better implementation and benchmar=
k.</div><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin:0p=
x 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><d=
iv dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote"=
style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);p=
adding-left:1ex"><span class=3D""><div dir=3D"ltr"><div></div><div>Mingxin =
Wang</div></div><p></p>--=C2=A0<br>You received this message because you ar=
e subscribed to the Google Groups "ISO C++ Standard - Future Proposals=
" group.<br></span>To unsubscribe from this group and stop receiving e=
mails from it, send an email to=C2=A0<a rel=3D"nofollow" style=3D"color:rgb=
(102,17,204)">std-proposal...@isocpp.org</a>.<br>To post to this group, sen=
d email to=C2=A0<a rel=3D"nofollow" style=3D"color:rgb(102,17,204)">std-pr.=
...@isocpp.org</a>.<span class=3D""><br>To view this discussion on the web v=
isit=C2=A0<a href=3D"https://groups.google.com/a/isocpp.org/d/msgid/std-pro=
posals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=3Demail=
&utm_source=3Dfooter" rel=3D"nofollow" target=3D"_blank">https://groups=
..google.<wbr>com/a/isocpp.org/d/msgid/std-p<wbr>roposals/35f0c5a1-5d16-4bbf=
-87<wbr>83-07b3f38f84e0%40isocpp.org</a>.<br></span></blockquote><div><br><=
/div></div></div></blockquote></div><span class=3D"">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/d94c1947-531c-40e5-8f10-bc2b917c84a9%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/d94c=
1947-531c-40e5-<wbr>8f10-bc2b917c84a9%40isocpp.org</a><wbr>.<br>
</blockquote></div><br></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAJH_FNVW2muiXziz2ef%2BXwTeFwGQYYDfWd=
8Uth9eiy8U4YqpTg%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNVW2muiXz=
iz2ef%2BXwTeFwGQYYDfWd8Uth9eiy8U4YqpTg%40mail.gmail.com</a>.<br />
--000000000000c414e60568e22bde--
.
Author: =?UTF-8?Q?Klaim_=2D_Jo=C3=ABl_Lamotte?= <mjklaim@gmail.com>
Date: Mon, 2 Apr 2018 23:31:00 +0200
Raw View
--000000000000c6be590568e45068
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On 2 April 2018 at 17:40, Mingxin Wang <wmx16835vv@163.com> wrote:
> On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=ABl Lamotte w=
rote:
>
>>
>> Although your proposal is interesting, this is only an implementation
>> detail of the polymorphic executors (which are already necessary in some
>> ways today) specification.
>> I don't know if your proposal is enough to implement these polymorphic
>> executors, but the specification only is concerned with the resulting
>> interface.
>>
>
> Built-in addresser template (aka. `static_proxy`) has similar interface
> with `std::any` in constructors and observers.
>
>
I know (if I remember correctly I'm one of the commenters mentionned in
it). But that's not my point. The point, (as mysen clarified) is that if
your proposal provide a way to implement this polymorphic executor,
it's not necessary to mention it in the proposal because it would be an
implementation detail.
I also agree with mysen that it would need to accept types, not "facades"
to work as specified.
Anyway your proposal is not in a position to be relied upon right now, it's
too early. But if it get traction, maybe propose a new version mentionning
that this proposal (if not already merged)
could be modified to use it.
> By the way, how would you specify a polymorphic executor using a
>> composition of several requirements (some might be custom), as the propo=
sal
>> requests?
>>
>
>
The "facade" are compatible to the C++ type system, including but not
> limited to inheritance, overloading, templates, and qualifiers. For
> example, we are able to define a facade template `Callable` to replace th=
e
> class template `std::function`:
>
> template <class T>
> facade Callable; // undefined
>
> template <class R, class... Args>
> facade Callable<R(Args...)> {
> R operator(Args... args);
> };
>
> ... and we could define a series of facades for the executors:
>
> facade OneWayExecutor {
> void execute(static_proxy<Callable<void()>> f) const;
> };
>
> template <class T>
> facade TwoWayExecutor {
> std::experimental::future<T> twoway_execute(static_proxy<Callable<void(=
)>>
> f) const;
> };
>
> ... and we can also define other facades based on them if necessary:
>
> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
> void wait_for_all_tasks_to_be_done_or_something();
> void reset_worker_count(std::size_t new_count);
> static std::string some_type_specific_description();
> };
>
>
This part is not what is needed. We need to be able to compose with several
requirements, not have to create another one.
> Providing there is a type `my_awesome_executor` meets the requirements
> defined by the facade, the following code shows its basic usage:
>
> const my_awesome_executor ex;
> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is not
> convertible to `non-const` reference;
> static_proxy<const MyExecutor&> p1(ex); // OK;
> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called;
> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructor
> is called;
> std::cout << p3.type() << std::endl; // OK; Print the result of
> `typeid(my_awesome_executor)`;
> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value is
> convertible to `const` reference;
> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;
> `non-volatile` value is convertible to `volatile` value;
> std::cout << p3.has_value() << std::endl; // OK; Print `false`, because
> the value has been moved to `p5`;
> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // OK;
> p5.execute([] { std::cout << "Although bad things happen sometimes..." <<
> std::endl; }); // Error; The `execute` function is not `volatile`;
>
>
Note that the current executor proposal to not necessarilly associate a
requirement to a specific interface. It would be possible
to have a requirement not change the interface (but change the semantic).
>
>>>
>>>> 4) Yes, it is minimal. The goal was never to specify a fully usable
>>>> thread pool - only that some minimal structure be provided such that
>>>> minimal executors can be defined. Trying to specify a perfect thread p=
ool,
>>>> assuming one to exist, would delay the executors specification for no =
gain.
>>>>
>>>>
>>>
>>> If it is a minimal one, I think it should not support "wait" or "stop"
>>> operations, and should be MoveConstructible. More importantly, the
>>> destructor should be non-blocking.
>>>
>>>
>> I don't think that's possible.
>> There is a need, in my experience, for an explicit synchronization point
>> with all the underlying threads to be able to make sense of the program.
>>
>
> I think that is what the users should concern about, not us. Users could
> use latches, futures or some other structural support utilities proposed =
in
> another paper of mine (P0642) to control the flow.
>
>
How do you provide the user any control if they don't ajve access to what
is controlling the underlying thread?
Threads are resources, they have to be managed explicitely in some ways.
Hiding them from the user is good but they still need to know what some
will be created and where their lifetime will end.
Also, the user is usually concerned with the task, not the thread.
> For example in your following example, the tasks pushed in that thread
>> pool can survive the lifetime of the thread pool. That makes
>> reasoning almost impossible. To put it another way: it goes against RAII
>> principles and definitely is not the good way to go.
>>
>
> I do not understand how you come to the conclusion that "it goes against
> RAII principles". If my understanding is right, RAII is about "initializi=
ng
> the resource when it is acquired", and I did not find my code against thi=
s
> principle. Is there anything I missed?
>
>
RAII imply, more importantly, that the resources acquired are guaranteed to
be released in a deterministic way, when the destructor is called.
It's important to make sure that after you destroying the thread pool ,
there should be no thread from that thread pool still alive, otherwise it
makes reasoning very hard.
Forcing either the user to call a function to end al the threads (maybe
returning a future, acting like a barrier), that must be called otherwise
the thread pool destructor will call terminate
OR guarantee that we will not get out from the thread-pool destructor until
all the managed threads are joined,
are important variations of the guarantee needed to keep reasonning with
the resources possible.
> Actually, this implementation could be abused if one does not have the
> ability to write concurrent programs correctly. This phenomenon is common
> in the whole C++ programming language, not only at this point.
>
>
I don't think it have anything to do with the other code. You explicitely
make threads live longer than the thread pool without providing life
ownership to the user.
To me, it's some kind of thread leak. It might not hurt, but it will
confuse a lot. (I've been there) In particular when trying to reason about
the user code. You are not sure when is finished what
just by reading the code.
> Anyway, the proposal is not supposed to provide much in thread pools and
>> other proposals will provide these, in variety I suppose (or predict).
>>
>
> I will be grateful if you could provide any relevant information.
>
>
Of course. It's mentioned in the design document, P0761R2 :
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0761r2.pdf
Here is the revelant part, in particular the last paragraph:
"Thread Pool Variations. Our proposal specifies a single thread pool type,
static_thread_pool, which
represents a simple thread pool which assumes that the creator knows the
correct thread count for the use
case. As a result, it assumes a pre-determined sizing and does not
automatically resize itself and has no
default size.
There exist heuristics for right-sizing a thread pool (both statically
determined like 2*std::thread::hardware
-_concurrency(), as well as dynamically adjusted), but these are considered
to be out of scope of this
proposal as a reasonable size pool is specific to the application and
hardware.
We recognize that alternative approaches serving other use cases exist and
anticipate additional thread pool
proposals. In particular, we are aware of a separate effort which will
propose an additional thread pool type,
dynamic_thread_pool, and we expect this type of thread pool to be both
dynamically and automatically
resizable."
So basically, there are other thread pool/execution context proposals on
the work, apparently.
I just don't know who is working on them. Maybe you can provide some
yourself, it can be separate proposals.
>
>>>
>> That's under-performant because of the task queue being shared by all th=
e
>> threads.
>>
>
> I would appreciate it if you could provide a better implementation and
> benchmark.
>
>
Well, all performant thread pools I know of use "work-stealing" algorithms
which imply having 1 queue per thread
and the algorithm re-equilibrate the workload depending on some
parametters. I understand it is not trivial
and didn't attempt to implement one (in critical cases I would do like you,
a "naive but working" one).
For example of such implementations, look at:
- Intel Threading Building Blocks;
- HPX;
- maybe Boost.Thread experimental thread pool do work stealing, I'm not
sure, I didn't check.
I also recommend checking this talk from Sean Parent clarifying the issue
with the code you provided: https://www.youtube.com/watch?v=3DzULU6Hhp42w
Also "C++ Concurrency In Action" book clarify the details of all that, and
if you didn't read it and the subject
is interesting to you, it would be very interesting for you.
A. Jo=C3=ABl Lamotte
> Mingxin Wang
>>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "ISO C++ Standard - Future Proposals" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to std-proposal...@isocpp.org.
>>> To post to this group, send email to std-pr...@isocpp.org.
>>> To view this discussion on the web visit https://groups.google.
>>> com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-5d16-4bbf-87
>>> 83-07b3f38f84e0%40isocpp.org
>>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/35f0c5a1-=
5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=3Demail&utm_source=3Dfo=
oter>
>>> .
>>>
>>
>> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/d94c1947-531c-40e5-
> 8f10-bc2b917c84a9%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/d94c1947-53=
1c-40e5-8f10-bc2b917c84a9%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoot=
er>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAOU91OMjQzTbT%2B3Wae63jvYpVVtr8Jpss6NuXLDMCg5A-=
sevDQ%40mail.gmail.com.
--000000000000c6be590568e45068
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 2 April 2018 at 17:40, Mingxin Wang <span dir=3D"ltr"><<a href=3D=
"mailto:wmx16835vv@163.com" target=3D"_blank">wmx16835vv@163.com</a>></s=
pan> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0p=
x 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=
=3D"ltr"><div>On Monday, April 2, 2018 at 9:16:10 PM UTC+8, Klaim - Jo=C3=
=ABl Lamotte wrote:<br></div><span class=3D"gmail-"><blockquote class=3D"gm=
ail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,=
204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div=
><br></div><div>Although your proposal is interesting, this is only an impl=
ementation detail of the polymorphic executors (which are already necessary=
in some ways today) specification.</div><div>I don't know if your prop=
osal is enough to implement these polymorphic executors, but the specificat=
ion only is concerned with the resulting interface.</div></div></div></bloc=
kquote><div><br></div></span><div>Built-in addresser template (aka. `static=
_proxy`) has similar interface with `std::any` in constructors and observer=
s.</div><span class=3D"gmail-"><div>=C2=A0</div></span></div></blockquote><=
div><br></div><div>I know (if I remember correctly I'm one of the comme=
nters mentionned in it). But that's not my point. The point, (as mysen =
clarified) is that if your proposal provide a way to implement this polymor=
phic executor,</div><div>it's not necessary to mention it in the propos=
al because it would be an implementation detail.</div><div>I also agree wit=
h mysen that it would need to accept types, not "facades" to work=
as specified.</div><div><br></div><div>Anyway your proposal is not in a po=
sition to be relied upon right now, it's too early. But if it get tract=
ion, maybe propose a new version mentionning that this proposal (if not alr=
eady merged)</div><div>could be modified to use it.</div><div><br></div><di=
v>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px=
0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D=
"ltr"><span class=3D"gmail-"><blockquote class=3D"gmail_quote" style=3D"mar=
gin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1=
ex"><div dir=3D"ltr"><div class=3D"gmail_quote">By the way, how would=C2=A0=
you specify a polymorphic executor using a composition of several requirem=
ents (some might be custom), as the proposal requests?</div></div></blockqu=
ote><div>=C2=A0<br></div></span></div></blockquote><blockquote class=3D"gma=
il_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,2=
04,204);padding-left:1ex"><div dir=3D"ltr"><span class=3D"gmail-"><div></di=
v></span><div>The "facade" are compatible to the C++ type system,=
including but not limited to inheritance, overloading, templates, and qual=
ifiers. For example, we are able to define a facade template `Callable` to =
replace the class template `std::function`:</div><div><br></div><div><div c=
lass=3D"gmail-m_9134289121095881724prettyprint" style=3D"border-width:1px;b=
order-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,25=
0,250);word-wrap:break-word"><code class=3D"gmail-m_9134289121095881724pret=
typrint"><div class=3D"gmail-m_9134289121095881724subprettyprint"><font col=
or=3D"#660066"><div class=3D"gmail-m_9134289121095881724subprettyprint">tem=
plate <class T></div><div class=3D"gmail-m_9134289121095881724subpret=
typrint">facade Callable; =C2=A0// undefined</div><div class=3D"gmail-m_913=
4289121095881724subprettyprint"><br></div><div class=3D"gmail-m_91342891210=
95881724subprettyprint">template <class R, class... Args></div><div c=
lass=3D"gmail-m_9134289121095881724subprettyprint">facade Callable<R(Arg=
s...)> {</div><div class=3D"gmail-m_9134289121095881724subprettyprint">=
=C2=A0 R operator(Args... args);</div><div class=3D"gmail-m_913428912109588=
1724subprettyprint">};</div></font></div></code></div><br>... and we could =
define a series of facades for the executors:</div><div><br></div><div><div=
class=3D"gmail-m_9134289121095881724prettyprint" style=3D"border-width:1px=
;border-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,=
250,250);word-wrap:break-word"><code class=3D"gmail-m_9134289121095881724pr=
ettyprint"><div class=3D"gmail-m_9134289121095881724subprettyprint"><font c=
olor=3D"#660066"><div class=3D"gmail-m_9134289121095881724subprettyprint">f=
acade OneWayExecutor {</div><div class=3D"gmail-m_9134289121095881724subpre=
ttyprint">=C2=A0 void execute(static_proxy<Callable<<wbr>void()>&g=
t; f) const;</div><div class=3D"gmail-m_9134289121095881724subprettyprint">=
};</div><div class=3D"gmail-m_9134289121095881724subprettyprint"><br></div>=
<div class=3D"gmail-m_9134289121095881724subprettyprint">template <class=
T></div><div class=3D"gmail-m_9134289121095881724subprettyprint">facade=
TwoWayExecutor {</div><div class=3D"gmail-m_9134289121095881724subprettypr=
int">=C2=A0 std::experimental::future<T> twoway_execute(static_proxy&=
lt;<wbr>Callable<void()>> f) const;</div><div class=3D"gmail-m_913=
4289121095881724subprettyprint">};</div></font></div></code></div><br>... a=
nd we can also define other facades based on them if necessary:</div><div><=
br></div><div><div class=3D"gmail-m_9134289121095881724prettyprint" style=
=3D"border-width:1px;border-style:solid;border-color:rgb(187,187,187);backg=
round-color:rgb(250,250,250);word-wrap:break-word"><code class=3D"gmail-m_9=
134289121095881724prettyprint"><div class=3D"gmail-m_9134289121095881724sub=
prettyprint"><div class=3D"gmail-m_9134289121095881724subprettyprint"><div =
class=3D"gmail-m_9134289121095881724subprettyprint">facade MyExecutor : One=
WayExecutor, TwoWayExecutor {</div><div class=3D"gmail-m_913428912109588172=
4subprettyprint">=C2=A0 void wait_for_all_tasks_to_be_done_<wbr>or_somethin=
g();</div><div class=3D"gmail-m_9134289121095881724subprettyprint">=C2=A0 v=
oid reset_worker_count(std::size_t new_count);</div><div class=3D"gmail-m_9=
134289121095881724subprettyprint">=C2=A0 static std::string some_type_speci=
fic_<wbr>description();</div><div class=3D"gmail-m_9134289121095881724subpr=
ettyprint">};</div></div></div></code></div><br></div></div></blockquote><d=
iv><br></div><div><br></div><div>This part is not what is needed. We need t=
o be able to compose with several requirements, not have to create another =
one.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margi=
n:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex=
"><div dir=3D"ltr"><div>Providing there is a type `my_awesome_executor` mee=
ts the requirements defined by the facade, the following code shows its bas=
ic usage:</div><div><br></div><div><div class=3D"gmail-m_913428912109588172=
4prettyprint" style=3D"background-color:rgb(250,250,250);border-color:rgb(1=
87,187,187);border-style:solid;border-width:1px;word-wrap:break-word"><code=
class=3D"gmail-m_9134289121095881724prettyprint"><div class=3D"gmail-m_913=
4289121095881724subprettyprint"><div class=3D"gmail-m_9134289121095881724su=
bprettyprint">const my_awesome_executor ex;</div><div class=3D"gmail-m_9134=
289121095881724subprettyprint">static_proxy<MyExecutor&> p0(ex); =
=C2=A0// Error; Because `const` value is not convertible to `non-const` ref=
erence;</div><div class=3D"gmail-m_9134289121095881724subprettyprint">stati=
c_proxy<const MyExecutor&> p1(ex); =C2=A0// OK;</div><div class=
=3D"gmail-m_9134289121095881724subprettyprint">static_proxy<MyExecutor&g=
t; p2(ex); =C2=A0// OK; The copy-constructor is called;</div><div class=3D"=
gmail-m_9134289121095881724subprettyprint">static_proxy<MyExecutor> p=
3(std::move(ex)); =C2=A0// OK; The move-constructor is called;</div><div cl=
ass=3D"gmail-m_9134289121095881724subprettyprint">std::cout << p3.typ=
e() << std::endl; =C2=A0// OK; Print the result of `typeid(my_awesome=
_executor)`;</div><div class=3D"gmail-m_9134289121095881724subprettyprint">=
static_proxy<const OneWayExecutor&> p4(p2); =C2=A0// OK; `non-con=
st` value is convertible to `const` reference;</div><div class=3D"gmail-m_9=
134289121095881724subprettyprint">static_proxy<volatile MyExecutor> p=
5(std::move(p3)); =C2=A0// OK; `non-volatile` value is convertible to `vola=
tile` value;</div><div class=3D"gmail-m_9134289121095881724subprettyprint">=
std::cout << p3.has_value() << std::endl; =C2=A0// OK; Print `f=
alse`, because the value has been moved to `p5`;</div><div class=3D"gmail-m=
_9134289121095881724subprettyprint">p4.execute([] { std::cout << &quo=
t;Life is so cool!" << std::endl; }); =C2=A0// OK;</div><div cla=
ss=3D"gmail-m_9134289121095881724subprettyprint">p5.execute([] { std::cout =
<< "Although bad things happen sometimes..." << std::=
endl; }); =C2=A0// Error; The `execute` function is not `volatile`;</div></=
div></code></div></div><span class=3D"gmail-"><div><br></div></span></div><=
/blockquote><div><br></div><div>Note that the current executor proposal to =
not necessarilly associate a requirement to a specific interface. It would =
be possible</div><div>to have a requirement not change the interface (but c=
hange the semantic).</div><div>=C2=A0</div><blockquote class=3D"gmail_quote=
" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);=
padding-left:1ex"><div dir=3D"ltr"><span class=3D"gmail-"><div></div><block=
quote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1=
px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"=
gmail_quote"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px =
0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"=
ltr"><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px=
0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><di=
v dir=3D"ltr">4) Yes, it is minimal. The goal was never to specify a fully =
usable thread pool - only that some minimal structure be provided such that=
minimal executors can be defined. Trying to specify a perfect thread pool,=
assuming one to exist, would delay the executors specification for no gain=
.. =C2=A0</div></blockquote><div><br></div><div>If it is a minimal one, I th=
ink it should not support "wait" or "stop" operations, =
and should be MoveConstructible. More importantly, the destructor should be=
non-blocking.</div><div><br></div></div></blockquote><div><br></div><div>I=
don't think that's possible.</div><div>There is a need, in my expe=
rience, for an explicit synchronization point with all the underlying threa=
ds to be able to make sense of the program.</div></div></div></blockquote><=
div><br></div></span><div>I think that is what the users should concern abo=
ut, not us. Users could use latches, futures or some other structural suppo=
rt utilities proposed in another paper of mine (P0642) to control the flow.=
</div><span class=3D"gmail-"><div>=C2=A0</div></span></div></blockquote><di=
v><br></div><div>How do you provide the user any control if they don't =
ajve access to what is controlling the underlying thread?</div><div>Threads=
are resources, they have to be managed explicitely in some ways. Hiding th=
em from the user is good but they still need to know what some will be crea=
ted and where their lifetime will end.</div><div>Also, the user is usually =
concerned with the task, not the thread.</div><div>=C2=A0</div><blockquote =
class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px sol=
id rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span class=3D"gmail=
-"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;bord=
er-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div =
class=3D"gmail_quote"><div>For example in your following example, the tasks=
pushed in that thread pool can survive the lifetime of the thread pool. Th=
at makes=C2=A0</div><div>reasoning almost impossible. To put it another way=
: it goes against RAII principles and definitely is not the good way to go.=
</div></div></div></blockquote><div><br></div></span><div>I do not understa=
nd how you come to the conclusion that "it goes against RAII principle=
s". If my understanding is right, RAII is about "initializing the=
resource when it is acquired", and I did not find my code against thi=
s principle. Is there anything I missed?</div><div><br></div></div></blockq=
uote><div><br></div><div>RAII imply, more importantly, that the resources a=
cquired are guaranteed to be released in a deterministic way, when the dest=
ructor is called.</div><div>It's important to make sure that after you =
destroying=C2=A0 the thread pool , there should be no thread from that thre=
ad pool still alive, otherwise it makes reasoning very hard.</div><div>Forc=
ing either the user to call a function to end al the threads (maybe returni=
ng a future, acting like a barrier), that must be called otherwise the thre=
ad pool destructor will call terminate</div><div>OR guarantee that we will =
not get out from the thread-pool destructor until all the managed threads a=
re joined,</div><div>are important variations of the guarantee needed to ke=
ep reasonning with the resources possible.</div><div>=C2=A0</div><blockquot=
e class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px s=
olid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>Ac=
tually, this implementation could be abused if one does not have the abilit=
y to write concurrent programs correctly. This=C2=A0phenomenon is common in=
the whole C++ programming language, not only at this point.</div><span cla=
ss=3D"gmail-"><div><br></div></span></div></blockquote><div><br></div><div>=
I don't think it have anything to do with the other code. You explicite=
ly make threads live longer than the thread pool without providing life own=
ership to the user.</div><div>To me, it's some kind of thread leak. It =
might not hurt, but it will confuse a lot. (I've been there) In particu=
lar when trying to reason about the user code. You are not sure when is fin=
ished what</div><div>just by reading the code.</div><div>=C2=A0</div><block=
quote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1=
px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span class=3D=
"gmail-"><div></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0=
px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div =
dir=3D"ltr"><div class=3D"gmail_quote"><div>Anyway, the proposal is not sup=
posed to provide much in thread pools and other proposals will provide thes=
e, in variety I suppose (or predict).</div></div></div></blockquote><div><b=
r></div></span><div>I will be grateful if you could provide any relevant in=
formation.<br></div><div><div class=3D"gmail-h5"><div>=C2=A0</div></div></d=
iv></div></blockquote><div><br></div><div>Of course. It's mentioned in =
the design document,=C2=A0P0761R2 :=C2=A0<a href=3D"http://www.open-std.org=
/jtc1/sc22/wg21/docs/papers/2018/p0761r2.pdf">http://www.open-std.org/jtc1/=
sc22/wg21/docs/papers/2018/p0761r2.pdf</a></div><div><br></div><div>Here is=
the revelant part, in particular the last paragraph:</div><div><br></div><=
div><div>"Thread Pool Variations. Our proposal specifies a single thre=
ad pool type, static_thread_pool, which</div><div>represents a simple threa=
d pool which assumes that the creator knows the correct thread count for th=
e use</div><div>case. As a result, it assumes a pre-determined sizing and d=
oes not automatically resize itself and has no</div><div>default size.</div=
><div><br></div><div>There exist heuristics for right-sizing a thread pool =
(both statically determined like 2*std::thread::hardware</div><div>-_concur=
rency(), as well as dynamically adjusted), but these are considered to be o=
ut of scope of this</div><div>proposal as a reasonable size pool is specifi=
c to the application and hardware.</div><div><br></div><div>We recognize th=
at alternative approaches serving other use cases exist and anticipate addi=
tional thread pool</div><div>proposals. In particular, we are aware of a se=
parate effort which will propose an additional thread pool type,</div><div>=
dynamic_thread_pool, and we expect this type of thread pool to be both dyna=
mically and automatically</div><div>resizable."</div></div><div><br></=
div><div>So basically, there are other thread pool/execution context propos=
als on the work, apparently.</div><div>I just don't know who is working=
on them. Maybe you can provide some yourself, it can be separate proposals=
..</div><div><br></div><div>=C2=A0</div><blockquote class=3D"gmail_quote" st=
yle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padd=
ing-left:1ex"><div dir=3D"ltr"><div><div class=3D"gmail-h5"><blockquote cla=
ss=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid =
rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quo=
te"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;bor=
der-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div=
></div><div><br></div></div></blockquote><div><br></div><div>That's und=
er-performant because of the task queue being shared by all the threads.</d=
iv></div></div></blockquote><div><br></div></div></div><div>I would appreci=
ate it if you could provide a better implementation and benchmark.</div><di=
v><br></div></div></blockquote><div><br></div><div>Well, all performant thr=
ead pools I know of use "work-stealing" algorithms which imply ha=
ving 1 queue per thread</div><div>and the algorithm re-equilibrate the work=
load depending on some parametters. I understand it is not trivial</div><di=
v>and didn't attempt to implement one (in critical cases I would do lik=
e you, a "naive but working" one).</div><div><br></div><div>For e=
xample of such implementations, look at:</div><div>=C2=A0- Intel Threading =
Building Blocks;</div><div>=C2=A0- HPX;</div><div>=C2=A0- maybe Boost.Threa=
d experimental thread pool do work stealing, I'm not sure, I didn't=
check.</div><div><br></div><div>I also recommend checking this talk from S=
ean Parent clarifying the issue with the code you provided:=C2=A0<a href=3D=
"https://www.youtube.com/watch?v=3DzULU6Hhp42w">https://www.youtube.com/wat=
ch?v=3DzULU6Hhp42w</a></div><div>Also "C++ Concurrency In Action"=
book clarify the details of all that, and if you didn't read it and th=
e subject</div><div>is interesting to you, it would be very interesting for=
you.</div><div><br></div><div>A. Jo=C3=ABl Lamotte</div><div><br></div><di=
v>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px=
0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D=
"ltr"><div></div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px =
0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=
=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=
=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding=
-left:1ex"><span class=3D"gmail-"><div dir=3D"ltr"><div></div><div>Mingxin =
Wang</div></div><p></p>--=C2=A0<br>You received this message because you ar=
e subscribed to the Google Groups "ISO C++ Standard - Future Proposals=
" group.<br></span>To unsubscribe from this group and stop receiving e=
mails from it, send an email to=C2=A0<a rel=3D"nofollow" style=3D"color:rgb=
(102,17,204)">std-proposal...@isocpp.org</a>.<br>To post to this group, sen=
d email to=C2=A0<a rel=3D"nofollow" style=3D"color:rgb(102,17,204)">std-pr.=
...@isocpp.org</a>.<span class=3D"gmail-"><br>To view this discussion on the=
web visit=C2=A0<a href=3D"https://groups.google.com/a/isocpp.org/d/msgid/s=
td-proposals/35f0c5a1-5d16-4bbf-8783-07b3f38f84e0%40isocpp.org?utm_medium=
=3Demail&utm_source=3Dfooter" rel=3D"nofollow" target=3D"_blank">https:=
//groups.google.<wbr>com/a/isocpp.org/d/msgid/std-p<wbr>roposals/35f0c5a1-5=
d16-4bbf-87<wbr>83-07b3f38f84e0%40isocpp.org</a>.<br></span></blockquote><d=
iv><br></div></div></div></blockquote></div><span class=3D"gmail-">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/d94c1947-531c-40e5-8f10-bc2b917c84a9%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/d94c=
1947-531c-40e5-<wbr>8f10-bc2b917c84a9%40isocpp.org</a><wbr>.<br>
</blockquote></div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOU91OMjQzTbT%2B3Wae63jvYpVVtr8Jpss6=
NuXLDMCg5A-sevDQ%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OMjQzTbT%=
2B3Wae63jvYpVVtr8Jpss6NuXLDMCg5A-sevDQ%40mail.gmail.com</a>.<br />
--000000000000c6be590568e45068--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Tue, 3 Apr 2018 02:58:18 -0700 (PDT)
Raw View
------=_Part_12653_432480661.1522749498079
Content-Type: multipart/alternative;
boundary="----=_Part_12654_1432559966.1522749498080"
------=_Part_12654_1432559966.1522749498080
Content-Type: text/plain; charset="UTF-8"
On Tuesday, April 3, 2018 at 2:19:48 AM UTC+8, my...@google.com wrote:
>
> I don't think that the facade concept is the problem so much as the
> intention of the polymorphic wrapper -- which is intended to behave just
> like any other executor. This means that the require semantics should work
> properly to create an executor which satisfies all of the requirements of
> the provided properties while also providing a type-agnostic wrapper. Also
> of note is that the original caller should be able to know if their
> executor fully satisfies the needs of a library to which it is passing the
> executor.
>
If one passes a type that does not meet the requirements, a compile error
occurs.
> I'm not totally clear what the static_proxy is doing in your suggestion,
> but it is pretty important to be able to have a type which can describe the
> set of properties which it can use with require() at compile time. Whether
> that's internally implemented through facades is more of an implementer
> decision, no?
>
In this proposal, there are little type traits for facades, but we can use
`std::is_constructible_v<facade_meta_t<F>, std::in_place_type_t<T>>` to
check whether type `T` has facade `F` at compile-time, if necessary.
I think that is what the users should concern about, not us. Users could
>> use latches, futures or some other structural support utilities proposed in
>> another paper of mine (P0642) to control the flow.
>>
>
> You can use latch-like or future-like objects for this purpose, but it's
> the responsibility of the context to know when it's resources are shut
> down, asking clients to be aware of the detail of how to track completion
> of resources seems strange.
>
> That said, there is a discussion going on about how to track groups of
> work completing within an executor more generally so that you don't need
> every executor (or really context) to support this at the level of "all
> work running in the context" because that is overkill. That said, the hope
> is to create a more generic facility for this purpose because it provides
> other things like a communication channel to indicate when work needs to
> complete (and potentially ways to complete that work through something like
> boost blocking).
>
> But going back to this scenario -- there is a ton of code that i've seen
> which basically uses the thread pool as a bundle of work + execution and
> the completion of execution exactly describes the completion of all that
> work. You don't _have_ to do this, but it is a useful facility and
> realistically, the resource does exist and someone is tracking that. Just a
> question of whether there is a concrete object which does that. I'm not
> clear what real simplicity benefit there is by removing this functionality.
> Particularly because the role of the executor is to create the lightweight
> stateless object, the context isn't intended to be passed around and
> certainly not intended to be copied...
>
On the one hand, for users, joining threads is an inefficient way for
synchronization, although it is easy to implement. In most cases I have
seen, these code could be easily reconstructed to avoid unnecessary context
switching overhead, using latches, barriers or facilities included in my
proposal P0642. On the other hand, for the library implementators, storing
the thread objects requires extra space, or maybe kernel resources, or even
more complex algorithms to maintain the objects, especially when the number
of threads in a thread pool varies at runtime.
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/c19f7ce3-87be-4b2c-9f5d-dc24065be28a%40isocpp.org.
------=_Part_12654_1432559966.1522749498080
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Tuesday, April 3, 2018 at 2:19:48 AM UTC+8, my...@googl=
e.com wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-lef=
t: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><=
div>I don't think that the facade concept is the problem so much as the=
intention of the polymorphic wrapper -- which is intended to behave just l=
ike any other executor. This means that the require semantics should work p=
roperly to create an executor which satisfies all of the requirements of th=
e provided properties while also providing a type-agnostic wrapper. Also of=
note is that the original caller should be able to know if their executor =
fully satisfies the needs of a library to which it is passing the executor.=
</div></div></blockquote><div><br></div><div>If one passes a type that does=
not meet the requirements, a compile error occurs.</div><div><br></div><bl=
ockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border=
-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div><br></div><=
div>I'm not totally clear what the static_proxy is doing in your sugges=
tion, but it is pretty important to be able to have a type which can descri=
be the set of properties which it can use with require() at compile time. W=
hether that's internally implemented through facades is more of an impl=
ementer decision, no?<br></div></div></blockquote><div><br></div><div>In th=
is proposal, there are little type traits for facades, but we can use `std:=
:is_constructible_v<facade_meta_t<F>, std::in_place_type_t<T>=
;>` to check whether type `T` has facade `F` at compile-time, if necessa=
ry.</div><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin: =
0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div d=
ir=3D"ltr"><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:=
0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div>I =
think that is what the users should concern about, not us. Users could use =
latches, futures or some other structural support utilities proposed in ano=
ther paper of mine (P0642) to control the flow.</div></div></blockquote><di=
v><br></div><div>You can use latch-like or future-like objects for this pur=
pose, but it's the responsibility of the context to know when it's =
resources are shut down, asking clients to be aware of the detail of how to=
track completion of resources seems strange.</div></div></blockquote><bloc=
kquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-l=
eft: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div><br></div><di=
v>That said, there is a discussion going on about how to track groups of wo=
rk completing within an executor more generally so that you don't need =
every executor (or really context) to support this at the level of "al=
l work running in the context" because that is overkill. That said, th=
e hope is to create a more generic facility for this purpose because it pro=
vides other things like a communication channel to indicate when work needs=
to complete (and potentially ways to complete that work through something =
like boost blocking).</div><div><br></div><div>But going back to this scena=
rio -- there is a ton of code that i've seen which basically uses the t=
hread pool as a bundle of work + execution and the completion of execution =
exactly describes the completion of all that work. You don't _have_ to =
do this, but it is a useful facility and realistically, the resource does e=
xist and someone is tracking that. Just a question of whether there is a co=
ncrete object which does that. I'm not clear what real simplicity benef=
it there is by removing this functionality. Particularly because the role o=
f the executor is to create the lightweight stateless object, the context i=
sn't intended to be passed around and certainly not intended to be copi=
ed...</div></div></blockquote><div><br></div><div>On the one hand, for user=
s, joining threads is an inefficient way for synchronization, although it i=
s easy to implement. In most cases I have seen, these code could be easily =
reconstructed to avoid unnecessary context switching overhead, using latche=
s, barriers or facilities included in my proposal P0642. On the other hand,=
for the library implementators, storing the thread objects requires extra =
space, or maybe=C2=A0kernel resources, or even more complex algorithms to m=
aintain the objects, especially when the number of threads in a thread pool=
varies at runtime.</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/c19f7ce3-87be-4b2c-9f5d-dc24065be28a%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/c19f7ce3-87be-4b2c-9f5d-dc24065be28a=
%40isocpp.org</a>.<br />
------=_Part_12654_1432559966.1522749498080--
------=_Part_12653_432480661.1522749498079--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Tue, 3 Apr 2018 02:58:28 -0700 (PDT)
Raw View
------=_Part_21265_1478648742.1522749508400
Content-Type: multipart/alternative;
boundary="----=_Part_21266_390250572.1522749508400"
------=_Part_21266_390250572.1522749508400
Content-Type: text/plain; charset="UTF-8"
On Tuesday, April 3, 2018 at 2:58:12 AM UTC+8, Lee Howes wrote:
>
> > Why do we need multi-dimensional iteration? Could you provide a
> meaningful use case where it would help in performance?
>
> for(each block in row) {
> for(each block in column) {
> perform DCT on image block
> }
> }
>
> or any number of algorithms applied to an image or similar data structure.
> Take a look at any CUDA code for examples. When hardware provides a 2-D
> iterator, you might as well give access to it.
>
> If the row size is prime, then implementing this using a 1D loop is going
> to include a nasty mod, which would end up running thousands of times in
> each GPU work item. Pretty inefficient in general.
>
From my point of view, GPU threads should not "share" the concept
"Executor" with CPU threads, because GPU threads are not in a same
shared-memory system with CPU threads, and has diverse memory model with
different synchronization mechanisms.
Let's may as well consider a more extreme case: suppose there are N tasks
and M available execution agents, where N is very large, M is even larger
than N, and we should map each task to a unique execution agent and launch.
- If the tasks are launched sequentially, the complexity of time is T1 =
O(N).
- If the tasks are launched in X groups, each group contains a total number
of (N / X) tasks, the complexity of time is T2 = O(X + N / X). It is
apparant that T2 = O(square root of N) is minimum when X equals to (square
root of N), and that is probably what you mean by "2-D".
- If the tasks are launched in X big groups, each big group contains Y
small groups, the complexity of time is T3 = O(X + Y + N / X / Y). It is
apparant that T3 = O(cube root of N) is minimum when X equals to (cube root
of N).
- If the tasks are launched in X big groups, each group contains X smaller
groups, and each smaller groups contains X much smaller groups... When X
equals to *e* (Euler's number, 2.71...), the time complexity O(ln(n)) is
minimized, and it is theoretically optimal to divide each work into 3
smaller ones. (There is also a proof in my proposal P0642).
Thus it is not optimal only to provide high-dimentional iterators, and
logarithmic complexity algorithm requires *random access* to the input.
However, it will make the API more difficult to use, and reduce the
extensibility to a certain extent. If there are cases where launching tasks
could be a bottleneck, I would recommend using random access algorithms
rather than 2-D iterators.
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/138265d8-bd89-4642-bded-20a474b80bad%40isocpp.org.
------=_Part_21266_390250572.1522749508400
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Tuesday, April 3, 2018 at 2:58:12 AM UTC+8, Lee Howes w=
rote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8e=
x;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr">>=C2=
=A0<span style=3D"color:rgb(34,34,34);font-family:arial,sans-serif;font-siz=
e:12.8px;font-style:normal;font-weight:400;letter-spacing:normal;text-align=
:start;text-indent:0px;text-transform:none;white-space:normal;word-spacing:=
0px;background-color:rgb(255,255,255);float:none;display:inline">Why do we =
need multi-dimensional iteration? Could you provide a meaningful use case w=
here it would help in performance?</span><div><span style=3D"color:rgb(34,3=
4,34);font-family:arial,sans-serif;font-size:12.8px;font-style:normal;font-=
weight:400;letter-spacing:normal;text-align:start;text-indent:0px;text-tran=
sform:none;white-space:normal;word-spacing:0px;background-color:rgb(255,255=
,255);float:none;display:inline"><br></span></div><div><span style=3D"color=
:rgb(34,34,34);font-family:arial,sans-serif;font-size:12.8px;font-style:nor=
mal;font-weight:400;letter-spacing:normal;text-align:start;text-indent:0px;=
text-transform:none;white-space:normal;word-spacing:0px;background-color:rg=
b(255,255,255);float:none;display:inline">for(each block in row) {</span></=
div><div><span style=3D"color:rgb(34,34,34);font-family:arial,sans-serif;fo=
nt-size:12.8px;font-style:normal;font-weight:400;letter-spacing:normal;text=
-align:start;text-indent:0px;text-transform:none;white-space:normal;word-sp=
acing:0px;background-color:rgb(255,255,255);float:none;display:inline">=C2=
=A0 for(each block in column) {</span></div><div><span style=3D"color:rgb(3=
4,34,34);font-family:arial,sans-serif;font-size:12.8px;font-style:normal;fo=
nt-weight:400;letter-spacing:normal;text-align:start;text-indent:0px;text-t=
ransform:none;white-space:normal;word-spacing:0px;background-color:rgb(255,=
255,255);float:none;display:inline">=C2=A0 =C2=A0 perform DCT on image bloc=
k</span></div><div><span style=3D"font-size:12.8px">=C2=A0 }</span></div><d=
iv><span style=3D"font-size:12.8px">}</span></div><div><span style=3D"font-=
size:12.8px"><br></span></div><div><span style=3D"font-size:12.8px">or any =
number of algorithms applied to an image or similar data structure. Take a =
look at any CUDA code for examples. When hardware provides a 2-D iterator, =
you might as well give access to it.</span></div><div><span style=3D"font-s=
ize:12.8px"><br></span></div><div><span style=3D"font-size:12.8px">If the r=
ow size is prime, then implementing this using a 1D loop is going to includ=
e a nasty mod, which would end up running thousands of times in each GPU wo=
rk item. Pretty inefficient in general.</span></div></div></blockquote><div=
><br></div><div>From my point of view, GPU threads should not "share&q=
uot; the concept "Executor" with CPU threads, because GPU threads=
are not in a same shared-memory system with CPU threads, and has diverse m=
emory model with different synchronization mechanisms.</div><div><br></div>=
<div>Let's may as well consider a more extreme case: suppose there are =
N tasks and M available execution agents, where N is very large, M is even =
larger than N, and we should map each task to a unique execution agent and =
launch.</div><div>- If the tasks are launched sequentially, the complexity =
of time is T1 =3D O(N).</div><div>- If the tasks are launched in X groups, =
each group contains a total number of (N / X) tasks, the complexity of time=
is T2 =3D O(X + N / X). It is apparant that T2 =3D O(square root of N) is =
minimum when X equals to (square root of N), and that is probably what you =
mean by "2-D".</div><div>- If the tasks are launched in X big gro=
ups, each big group contains Y small groups, the complexity of time is T3 =
=3D O(X + Y + N / X / Y). It is apparant that T3 =3D O(cube root of N) is m=
inimum when X equals to (cube root of N).</div><div>- If the tasks are laun=
ched in X big groups, each group contains X smaller groups, and each smalle=
r groups contains X much smaller groups... When X equals to <i>e</i> (Euler=
's number, 2.71...), the time complexity O(ln(n)) is minimized, and=C2=
=A0it is theoretically optimal to divide each work into 3 smaller ones. (Th=
ere is also a proof in my proposal P0642).</div><div><br></div><div>Thus it=
is not optimal only to provide high-dimentional iterators, and logarithmic=
complexity algorithm requires <b>random access</b> to the input. However, =
it will make the API more difficult to use, and reduce the extensibility to=
a certain extent. If there are cases where launching tasks could be a bott=
leneck, I would recommend using random access algorithms rather than 2-D it=
erators.</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/138265d8-bd89-4642-bded-20a474b80bad%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/138265d8-bd89-4642-bded-20a474b80bad=
%40isocpp.org</a>.<br />
------=_Part_21266_390250572.1522749508400--
------=_Part_21265_1478648742.1522749508400--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Tue, 3 Apr 2018 02:58:48 -0700 (PDT)
Raw View
------=_Part_20781_139672763.1522749528303
Content-Type: multipart/alternative;
boundary="----=_Part_20782_554628329.1522749528304"
------=_Part_20782_554628329.1522749528304
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Tuesday, April 3, 2018 at 5:31:43 AM UTC+8, Klaim - Jo=C3=ABl Lamotte wr=
ote:
>
> I know (if I remember correctly I'm one of the commenters mentionned in=
=20
> it).
>
Thank you again for your valuable comments! Your name is in the=20
"Acknowledgement" part in P0957.
=20
> But that's not my point. The point, (as mysen clarified) is that if your=
=20
> proposal provide a way to implement this polymorphic executor,
> it's not necessary to mention it in the proposal because it would be an=
=20
> implementation detail.
> I also agree with mysen that it would need to accept types, not "facades"=
=20
> to work as specified.
>
Facades are types, and could be used like any other placeholder types in=20
C++.
Anyway your proposal is not in a position to be relied upon right now, it's=
=20
> too early. But if it get traction, maybe propose a new version mentionnin=
g=20
> that this proposal (if not already merged)
> could be modified to use it.
>
I am introducing this proposal to provide a uniform pattern for polymorphic=
=20
programming to avoid unnecessary redesign. For example, in `std::function`,=
=20
there are member functions `target_type` and `operator bool()`; while in=20
`std::any`, there are similar member functions `type` and `has_value` =E2=
=80=94=20
they actually has the same semantics.
By the way, how would you specify a polymorphic executor using a=20
>>> composition of several requirements (some might be custom), as the prop=
osal=20
>>> requests?
>>>
>> =20
>>
> The "facade" are compatible to the C++ type system, including but not=20
>> limited to inheritance, overloading, templates, and qualifiers. For=20
>> example, we are able to define a facade template `Callable` to replace t=
he=20
>> class template `std::function`:
>>
>> template <class T>
>> facade Callable; // undefined
>>
>> template <class R, class... Args>
>> facade Callable<R(Args...)> {
>> R operator(Args... args);
>> };
>>
>> ... and we could define a series of facades for the executors:
>>
>> facade OneWayExecutor {
>> void execute(static_proxy<Callable<void()>> f) const;
>> };
>>
>> template <class T>
>> facade TwoWayExecutor {
>> std::experimental::future<T>=20
>> twoway_execute(static_proxy<Callable<void()>> f) const;
>> };
>>
>> ... and we can also define other facades based on them if necessary:
>>
>> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
>> void wait_for_all_tasks_to_be_done_or_something();
>> void reset_worker_count(std::size_t new_count);
>> static std::string some_type_specific_description();
>> };
>>
>>
> This part is not what is needed. We need to be able to compose with=20
> several requirements, not have to create another one.
>
Do you mean conjunction? In the example above, `MyExecutor` is a=20
conjunction of `OneWayExecutor` and `TwoWayExecutor`.
Providing there is a type `my_awesome_executor` meets the requirements=20
>> defined by the facade, the following code shows its basic usage:
>>
>> const my_awesome_executor ex;
>> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is no=
t=20
>> convertible to `non-const` reference;
>> static_proxy<const MyExecutor&> p1(ex); // OK;
>> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called;
>> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructor=
=20
>> is called;
>> std::cout << p3.type() << std::endl; // OK; Print the result of=20
>> `typeid(my_awesome_executor)`;
>> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value is=
=20
>> convertible to `const` reference;
>> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;=20
>> `non-volatile` value is convertible to `volatile` value;
>> std::cout << p3.has_value() << std::endl; // OK; Print `false`, because=
=20
>> the value has been moved to `p5`;
>> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // OK=
;
>> p5.execute([] { std::cout << "Although bad things happen sometimes..." <=
<=20
>> std::endl; }); // Error; The `execute` function is not `volatile`;
>>
>>
> Note that the current executor proposal to not necessarilly associate a=
=20
> requirement to a specific interface. It would be possible
> to have a requirement not change the interface (but change the semantic).
>
I do not understand what you mean by this paragraph. Could you please=20
clarify it?
4) Yes, it is minimal. The goal was never to specify a fully usable thread=
=20
>>>>> pool - only that some minimal structure be provided such that minimal=
=20
>>>>> executors can be defined. Trying to specify a perfect thread pool, as=
suming=20
>>>>> one to exist, would delay the executors specification for no gain. =
=20
>>>>>
>>>>
>>>> If it is a minimal one, I think it should not support "wait" or "stop"=
=20
>>>> operations, and should be MoveConstructible. More importantly, the=20
>>>> destructor should be non-blocking.
>>>>
>>>>
>>> I don't think that's possible.
>>> There is a need, in my experience, for an explicit synchronization poin=
t=20
>>> with all the underlying threads to be able to make sense of the program=
..
>>>
>>
>> I think that is what the users should concern about, not us. Users could=
=20
>> use latches, futures or some other structural support utilities proposed=
in=20
>> another paper of mine (P0642) to control the flow.
>> =20
>>
>
> How do you provide the user any control if they don't ajve access to what=
=20
> is controlling the underlying thread?
> Threads are resources, they have to be managed explicitely in some ways.=
=20
> Hiding them from the user is good but they still need to know what some=
=20
> will be created and where their lifetime will end.
> Also, the user is usually concerned with the task, not the thread.
>
As I replied to Mysen, I think it is not necessary both for users and=20
library implementators.
For example in your following example, the tasks pushed in that thread pool=
=20
>>> can survive the lifetime of the thread pool. That makes=20
>>> reasoning almost impossible. To put it another way: it goes against RAI=
I=20
>>> principles and definitely is not the good way to go.
>>>
>>
>> I do not understand how you come to the conclusion that "it goes against=
=20
>> RAII principles". If my understanding is right, RAII is about "initializ=
ing=20
>> the resource when it is acquired", and I did not find my code against th=
is=20
>> principle. Is there anything I missed?
>>
>
> RAII imply, more importantly, that the resources acquired are guaranteed=
=20
> to be released in a deterministic way, when the destructor is called.
> It's important to make sure that after you destroying the thread pool ,=
=20
> there should be no thread from that thread pool still alive, otherwise it=
=20
> makes reasoning very hard.
>
Forcing either the user to call a function to end al the threads (maybe=20
> returning a future, acting like a barrier), that must be called otherwise=
=20
> the thread pool destructor will call terminate
> OR guarantee that we will not get out from the thread-pool destructor=20
> until all the managed threads are joined,
> are important variations of the guarantee needed to keep reasonning with=
=20
> the resources possible.
>
I think if the thread pool is correctly used, the task queue shall always=
=20
be empty when destroying the thread pool, and the resources (mutex, queue,=
=20
etc.) would be released shortly after the destruction.
Actually, this implementation could be abused if one does not have the=20
>> ability to write concurrent programs correctly. This phenomenon is commo=
n=20
>> in the whole C++ programming language, not only at this point.
>>
>>
> I don't think it have anything to do with the other code. You explicitely=
=20
> make threads live longer than the thread pool without providing life=20
> ownership to the user.
> To me, it's some kind of thread leak. It might not hurt, but it will=20
> confuse a lot. (I've been there) In particular when trying to reason abou=
t=20
> the user code. You are not sure when is finished what
> just by reading the code.
>
I think this is a part of the difficulty of concurrent programming.=20
However, the difficulty will not be reduced effectively by joining the=20
threads, and will definitely reduce performance.
Anyway, the proposal is not supposed to provide much in thread pools and=20
>>> other proposals will provide these, in variety I suppose (or predict).
>>>
>>
>> I will be grateful if you could provide any relevant information.
>> =20
>>
>
> Of course. It's mentioned in the design document, P0761R2 :=20
> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0761r2.pdf
>
> Here is the revelant part, in particular the last paragraph:
>
> "Thread Pool Variations. Our proposal specifies a single thread pool type=
,=20
> static_thread_pool, which
> represents a simple thread pool which assumes that the creator knows the=
=20
> correct thread count for the use
> case. As a result, it assumes a pre-determined sizing and does not=20
> automatically resize itself and has no
> default size.
>
> There exist heuristics for right-sizing a thread pool (both statically=20
> determined like 2*std::thread::hardware
> -_concurrency(), as well as dynamically adjusted), but these are=20
> considered to be out of scope of this
> proposal as a reasonable size pool is specific to the application and=20
> hardware.
>
> We recognize that alternative approaches serving other use cases exist an=
d=20
> anticipate additional thread pool
> proposals. In particular, we are aware of a separate effort which will=20
> propose an additional thread pool type,
> dynamic_thread_pool, and we expect this type of thread pool to be both=20
> dynamically and automatically
> resizable."
>
> So basically, there are other thread pool/execution context proposals on=
=20
> the work, apparently.
> I just don't know who is working on them. Maybe you can provide some=20
> yourself, it can be separate proposals.
>
Actually, I have implemented various of thread pools on different platforms=
=20
with different mechanisms (as I mentioned, bounded queue, keep-alive=20
duration, threads with attributes, work-stealing, timing, merging, etc.),=
=20
but I have not finished related technical specifications that reasonable=20
and motivating enough yet.
I would appreciate it if you could provide a better implementation and=20
>> benchmark.
>>
>
> Well, all performant thread pools I know of use "work-stealing" algorithm=
s=20
> which imply having 1 queue per thread
> and the algorithm re-equilibrate the workload depending on some=20
> parametters. I understand it is not trivial
> and didn't attempt to implement one (in critical cases I would do like=20
> you, a "naive but working" one).
>
> For example of such implementations, look at:
> - Intel Threading Building Blocks;
> - HPX;
> - maybe Boost.Thread experimental thread pool do work stealing, I'm not=
=20
> sure, I didn't check.
>
As far as I am concered, "work-stealing" strategy is useful almost only=20
when there are a lot of `wait` in our original code, and we want to=20
reconstruct them within a short period to increase performance. However,=20
"work-stealing" strategy is usually inefficient in well-design algorithms.
I also recommend checking this talk from Sean Parent clarifying the issue=
=20
> with the code you provided: https://www.youtube.com/watch?v=3DzULU6Hhp42w
> Also "C++ Concurrency In Action" book clarify the details of all that, an=
d=20
> if you didn't read it and the subject
> is interesting to you, it would be very interesting for you.
>
Thank you for the recommendations. I will check it out.
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309%40isocpp.or=
g.
------=_Part_20782_554628329.1522749528304
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Tuesday, April 3, 2018 at 5:31:43 AM UTC+8, Klaim - Jo=
=C3=ABl Lamotte wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;=
margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=
=3D"ltr"><div><div class=3D"gmail_quote"><div>I know (if I remember correct=
ly I'm one of the commenters mentionned in it).</div></div></div></div>=
</blockquote><div><br></div><div>Thank you again for your valuable comments=
! Your name is in the "Acknowledgement" part in P0957.</div><div>=
=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-lef=
t: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><=
div><div class=3D"gmail_quote"><div>But that's not my point. The point,=
(as mysen clarified) is that if your proposal provide a way to implement t=
his polymorphic executor,</div><div>it's not necessary to mention it in=
the proposal because it would be an implementation detail.</div><div>I als=
o agree with mysen that it would need to accept types, not "facades&qu=
ot; to work as specified.</div></div></div></div></blockquote><div><br></di=
v><div>Facades are types, and could be used like any other placeholder type=
s in C++.</div><div><br></div><blockquote class=3D"gmail_quote" style=3D"ma=
rgin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;">=
<div dir=3D"ltr"><div><div class=3D"gmail_quote"><div>Anyway your proposal =
is not in a position to be relied upon right now, it's too early. But i=
f it get traction, maybe propose a new version mentionning that this propos=
al (if not already merged)</div><div>could be modified to use it.</div></di=
v></div></div></blockquote><div><br></div><div>I am introducing this propos=
al to provide a uniform pattern for polymorphic programming to avoid unnece=
ssary redesign. For example, in `std::function`, there are member functions=
`target_type` and `operator bool()`; while in `std::any`, there are simila=
r member functions `type` and `has_value` =E2=80=94 they actually has the s=
ame semantics.</div><div><br></div><blockquote class=3D"gmail_quote" style=
=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: =
1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmai=
l_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,20=
4,204);padding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_=
quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,=
204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote">By the w=
ay, how would=C2=A0 you specify a polymorphic executor using a composition =
of several requirements (some might be custom), as the proposal requests?</=
div></div></blockquote><div>=C2=A0<br></div></span></div></blockquote><bloc=
kquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:=
1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><div></=
div></span><div>The "facade" are compatible to the C++ type syste=
m, including but not limited to inheritance, overloading, templates, and qu=
alifiers. For example, we are able to define a facade template `Callable` t=
o replace the class template `std::function`:</div><div><br></div><div><div=
style=3D"border-width:1px;border-style:solid;border-color:rgb(187,187,187)=
;background-color:rgb(250,250,250);word-wrap:break-word"><code><div><font c=
olor=3D"#660066"><div>template <class T></div><div>facade Callable; =
=C2=A0// undefined</div><div><br></div><div>template <class R, class... =
Args></div><div>facade Callable<R(Args...)> {</div><div>=C2=A0 R o=
perator(Args... args);</div><div>};</div></font></div></code></div><br>... =
and we could define a series of facades for the executors:</div><div><br></=
div><div><div style=3D"border-width:1px;border-style:solid;border-color:rgb=
(187,187,187);background-color:rgb(250,250,250);word-wrap:break-word"><code=
><div><font color=3D"#660066"><div>facade OneWayExecutor {</div><div>=C2=A0=
void execute(static_proxy<Callable<<wbr>void()>> f) const;</di=
v><div>};</div><div><br></div><div>template <class T></div><div>facad=
e TwoWayExecutor {</div><div>=C2=A0 std::experimental::future<T> twow=
ay_execute(static_proxy<<wbr>Callable<void()>> f) const;</div><=
div>};</div></font></div></code></div><br>... and we can also define other =
facades based on them if necessary:</div><div><br></div><div><div style=3D"=
border-width:1px;border-style:solid;border-color:rgb(187,187,187);backgroun=
d-color:rgb(250,250,250);word-wrap:break-word"><code><div><div><div>facade =
MyExecutor : OneWayExecutor, TwoWayExecutor {</div><div>=C2=A0 void wait_fo=
r_all_tasks_to_be_done_<wbr>or_something();</div><div>=C2=A0 void reset_wor=
ker_count(std::size_t new_count);</div><div>=C2=A0 static std::string some_=
type_specific_<wbr>description();</div><div>};</div></div></div></code></di=
v><br></div></div></blockquote><div><br></div><div>This part is not what is=
needed. We need to be able to compose with several requirements, not have =
to create another one.</div></div></div></blockquote><div><br></div><div>Do=
you mean=C2=A0conjunction? In the example above, `MyExecutor` is a conjunc=
tion of `OneWayExecutor` and `TwoWayExecutor`.</div><div><br></div><blockqu=
ote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left=
: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_q=
uote"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;b=
order-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><d=
iv>Providing there is a type `my_awesome_executor` meets the requirements d=
efined by the facade, the following code shows its basic usage:</div><div><=
br></div><div><div style=3D"background-color:rgb(250,250,250);border-color:=
rgb(187,187,187);border-style:solid;border-width:1px;word-wrap:break-word">=
<code><div><div>const my_awesome_executor ex;</div><div>static_proxy<MyE=
xecutor&> p0(ex); =C2=A0// Error; Because `const` value is not conve=
rtible to `non-const` reference;</div><div>static_proxy<const MyExecutor=
&> p1(ex); =C2=A0// OK;</div><div>static_proxy<MyExecutor> p2(=
ex); =C2=A0// OK; The copy-constructor is called;</div><div>static_proxy<=
;MyExecutor> p3(std::move(ex)); =C2=A0// OK; The move-constructor is cal=
led;</div><div>std::cout << p3.type() << std::endl; =C2=A0// OK=
; Print the result of `typeid(my_awesome_executor)`;</div><div>static_proxy=
<const OneWayExecutor&> p4(p2); =C2=A0// OK; `non-const` value is=
convertible to `const` reference;</div><div>static_proxy<volatile MyExe=
cutor> p5(std::move(p3)); =C2=A0// OK; `non-volatile` value is convertib=
le to `volatile` value;</div><div>std::cout << p3.has_value() <<=
; std::endl; =C2=A0// OK; Print `false`, because the value has been moved t=
o `p5`;</div><div>p4.execute([] { std::cout << "Life is so cool!=
" << std::endl; }); =C2=A0// OK;</div><div>p5.execute([] { std::=
cout << "Although bad things happen sometimes..." << =
std::endl; }); =C2=A0// Error; The `execute` function is not `volatile`;</d=
iv></div></code></div></div><span><div><br></div></span></div></blockquote>=
<div><br></div><div>Note that the current executor proposal to not necessar=
illy associate a requirement to a specific interface. It would be possible<=
/div><div>to have a requirement not change the interface (but change the se=
mantic).</div></div></div></blockquote><div><br></div><div>I do not underst=
and what you mean by this=C2=A0paragraph. Could you please clarify it?</div=
><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin=
-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"lt=
r"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"ma=
rgin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:=
1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" style=3D"marg=
in:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1e=
x"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_q=
uote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,2=
04);padding-left:1ex"><div dir=3D"ltr"><blockquote class=3D"gmail_quote" st=
yle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padd=
ing-left:1ex"><div dir=3D"ltr">4) Yes, it is minimal. The goal was never to=
specify a fully usable thread pool - only that some minimal structure be p=
rovided such that minimal executors can be defined. Trying to specify a per=
fect thread pool, assuming one to exist, would delay the executors specific=
ation for no gain. =C2=A0</div></blockquote><div><br></div><div>If it is a =
minimal one, I think it should not support "wait" or "stop&q=
uot; operations, and should be MoveConstructible. More importantly, the des=
tructor should be non-blocking.</div><div><br></div></div></blockquote><div=
><br></div><div>I don't think that's possible.</div><div>There is a=
need, in my experience, for an explicit synchronization point with all the=
underlying threads to be able to make sense of the program.</div></div></d=
iv></blockquote><div><br></div></span><div>I think that is what the users s=
hould concern about, not us. Users could use latches, futures or some other=
structural support utilities proposed in another paper of mine (P0642) to =
control the flow.</div><span><div>=C2=A0</div></span></div></blockquote><di=
v><br></div><div>How do you provide the user any control if they don't =
ajve access to what is controlling the underlying thread?</div><div>Threads=
are resources, they have to be managed explicitely in some ways. Hiding th=
em from the user is good but they still need to know what some will be crea=
ted and where their lifetime will end.</div><div>Also, the user is usually =
concerned with the task, not the thread.</div></div></div></blockquote><div=
><br></div><div>As I replied to=C2=A0Mysen, I think it is not necessary bot=
h for users and library implementators.</div><div><br></div><blockquote cla=
ss=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #=
ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><=
blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-l=
eft:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><bl=
ockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-lef=
t:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=
=3D"gmail_quote"><div>For example in your following example, the tasks push=
ed in that thread pool can survive the lifetime of the thread pool. That ma=
kes=C2=A0</div><div>reasoning almost impossible. To put it another way: it =
goes against RAII principles and definitely is not the good way to go.</div=
></div></div></blockquote><div><br></div></span><div>I do not understand ho=
w you come to the conclusion that "it goes against RAII principles&quo=
t;. If my understanding is right, RAII is about "initializing the reso=
urce when it is acquired", and I did not find my code against this pri=
nciple. Is there anything I missed?</div></div></blockquote><div><br></div>=
<div>RAII imply, more importantly, that the resources acquired are guarante=
ed to be released in a deterministic way, when the destructor is called.</d=
iv><div>It's important to make sure that after you destroying=C2=A0 the=
thread pool , there should be no thread from that thread pool still alive,=
otherwise it makes reasoning very hard.</div></div></div></blockquote><blo=
ckquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-=
left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gma=
il_quote"><div>Forcing either the user to call a function to end al the thr=
eads (maybe returning a future, acting like a barrier), that must be called=
otherwise the thread pool destructor will call terminate</div><div>OR guar=
antee that we will not get out from the thread-pool destructor until all th=
e managed threads are joined,</div><div>are important variations of the gua=
rantee needed to keep reasonning with the resources possible.</div></div></=
div></blockquote><div><br></div><div>I think if the thread pool is correctl=
y used, the task queue shall always be empty when destroying the thread poo=
l, and the resources (mutex, queue, etc.) would be released shortly after t=
he destruction.</div><div><br></div><blockquote class=3D"gmail_quote" style=
=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: =
1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmai=
l_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,20=
4,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>Actually, this im=
plementation could be abused if one does not have the ability to write conc=
urrent programs correctly. This=C2=A0phenomenon is common in the whole C++ =
programming language, not only at this point.</div><span><div><br></div></s=
pan></div></blockquote><div><br></div><div>I don't think it have anythi=
ng to do with the other code. You explicitely make threads live longer than=
the thread pool without providing life ownership to the user.</div><div>To=
me, it's some kind of thread leak. It might not hurt, but it will conf=
use a lot. (I've been there) In particular when trying to reason about =
the user code. You are not sure when is finished what</div><div>just by rea=
ding the code.</div></div></div></blockquote><div><br></div><div>I think th=
is is a part of the difficulty of concurrent programming. However, the diff=
iculty will not be reduced effectively by joining the threads, and will def=
initely reduce performance.</div><div><br></div><blockquote class=3D"gmail_=
quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;pa=
dding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote c=
lass=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px soli=
d rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><div></div><blo=
ckquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left=
:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=
=3D"gmail_quote"><div>Anyway, the proposal is not supposed to provide much =
in thread pools and other proposals will provide these, in variety I suppos=
e (or predict).</div></div></div></blockquote><div><br></div></span><div>I =
will be grateful if you could provide any relevant information.<br></div><d=
iv><div><div>=C2=A0</div></div></div></div></blockquote><div><br></div><div=
>Of course. It's mentioned in the design document,=C2=A0P0761R2 :=C2=A0=
<a href=3D"http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0761r2.=
pdf" target=3D"_blank" rel=3D"nofollow" onmousedown=3D"this.href=3D'htt=
p://www.google.com/url?q\x3dhttp%3A%2F%2Fwww.open-std.org%2Fjtc1%2Fsc22%2Fw=
g21%2Fdocs%2Fpapers%2F2018%2Fp0761r2.pdf\x26sa\x3dD\x26sntz\x3d1\x26usg\x3d=
AFQjCNFcSBH28Da4H15rmQ4_4sZAFpXdbw';return true;" onclick=3D"this.href=
=3D'http://www.google.com/url?q\x3dhttp%3A%2F%2Fwww.open-std.org%2Fjtc1=
%2Fsc22%2Fwg21%2Fdocs%2Fpapers%2F2018%2Fp0761r2.pdf\x26sa\x3dD\x26sntz\x3d1=
\x26usg\x3dAFQjCNFcSBH28Da4H15rmQ4_4sZAFpXdbw';return true;">http://www=
..open-std.org/<wbr>jtc1/sc22/wg21/docs/papers/<wbr>2018/p0761r2.pdf</a></di=
v><div><br></div><div>Here is the revelant part, in particular the last par=
agraph:</div><div><br></div><div><div>"Thread Pool Variations. Our pro=
posal specifies a single thread pool type, static_thread_pool, which</div><=
div>represents a simple thread pool which assumes that the creator knows th=
e correct thread count for the use</div><div>case. As a result, it assumes =
a pre-determined sizing and does not automatically resize itself and has no=
</div><div>default size.</div><div><br></div><div>There exist heuristics fo=
r right-sizing a thread pool (both statically determined like 2*std::thread=
::hardware</div><div>-_concurrency(), as well as dynamically adjusted), but=
these are considered to be out of scope of this</div><div>proposal as a re=
asonable size pool is specific to the application and hardware.</div><div><=
br></div><div>We recognize that alternative approaches serving other use ca=
ses exist and anticipate additional thread pool</div><div>proposals. In par=
ticular, we are aware of a separate effort which will propose an additional=
thread pool type,</div><div>dynamic_thread_pool, and we expect this type o=
f thread pool to be both dynamically and automatically</div><div>resizable.=
"</div></div><div><br></div><div>So basically, there are other thread =
pool/execution context proposals on the work, apparently.</div><div>I just =
don't know who is working on them. Maybe you can provide some yourself,=
it can be separate proposals.</div></div></div></blockquote><div><br></div=
><div>Actually, I have implemented various of thread pools on different pla=
tforms with different mechanisms (as I mentioned, bounded queue, keep-alive=
duration, threads with attributes, work-stealing, timing, merging, etc.), =
but I have not finished related=C2=A0technical specifications that reasonab=
le and=C2=A0motivating enough yet.</div><div><br></div><blockquote class=3D=
"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc s=
olid;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><block=
quote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1=
px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div>I would a=
ppreciate it if you could provide a better implementation and benchmark.</d=
iv></div></blockquote><div><br></div><div>Well, all performant thread pools=
I know of use "work-stealing" algorithms which imply having 1 qu=
eue per thread</div><div>and the algorithm re-equilibrate the workload depe=
nding on some parametters. I understand it is not trivial</div><div>and did=
n't attempt to implement one (in critical cases I would do like you, a =
"naive but working" one).</div><div><br></div><div>For example of=
such implementations, look at:</div><div>=C2=A0- Intel Threading Building =
Blocks;</div><div>=C2=A0- HPX;</div><div>=C2=A0- maybe Boost.Thread experim=
ental thread pool do work stealing, I'm not sure, I didn't check.</=
div></div></div></blockquote><div><br></div><div>As far as I am concered, &=
quot;work-stealing" strategy is useful almost only when there are a lo=
t of `wait` in our original code, and we want to reconstruct them within a =
short period to increase performance. However, "work-stealing" st=
rategy=C2=A0is usually inefficient in well-design algorithms.</div><div><br=
></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.=
8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"><div c=
lass=3D"gmail_quote"><div>I also recommend checking this talk from Sean Par=
ent clarifying the issue with the code you provided:=C2=A0<a href=3D"https:=
//www.youtube.com/watch?v=3DzULU6Hhp42w" target=3D"_blank" rel=3D"nofollow"=
onmousedown=3D"this.href=3D'https://www.youtube.com/watch?v\x3dzULU6Hh=
p42w';return true;" onclick=3D"this.href=3D'https://www.youtube.com=
/watch?v\x3dzULU6Hhp42w';return true;">https://www.youtube.<wbr>com/wat=
ch?v=3DzULU6Hhp42w</a></div><div>Also "C++ Concurrency In Action"=
book clarify the details of all that, and if you didn't read it and th=
e subject</div><div>is interesting to you, it would be very interesting for=
you.</div></div></div></blockquote><div><br></div><div>Thank you for the=
=C2=A0recommendations.=C2=A0I will check it out.</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309=
%40isocpp.org</a>.<br />
------=_Part_20782_554628329.1522749528304--
------=_Part_20781_139672763.1522749528303--
.
Author: =?UTF-8?Q?Micha=C5=82_Dominiak?= <griwes@griwes.info>
Date: Tue, 03 Apr 2018 13:00:18 +0000
Raw View
--001a114db1107025cb0568f14a4f
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Tue, Apr 3, 2018 at 11:58 AM Mingxin Wang <wmx16835vv@163.com> wrote:
> On Tuesday, April 3, 2018 at 5:31:43 AM UTC+8, Klaim - Jo=C3=ABl Lamotte =
wrote:
>>
>> I know (if I remember correctly I'm one of the commenters mentionned in
>> it).
>>
>
> Thank you again for your valuable comments! Your name is in the
> "Acknowledgement" part in P0957.
>
>
>> But that's not my point. The point, (as mysen clarified) is that if your
>> proposal provide a way to implement this polymorphic executor,
>> it's not necessary to mention it in the proposal because it would be an
>> implementation detail.
>> I also agree with mysen that it would need to accept types, not "facades=
"
>> to work as specified.
>>
>
> Facades are types, and could be used like any other placeholder types in
> C++.
>
> Anyway your proposal is not in a position to be relied upon right now,
>> it's too early. But if it get traction, maybe propose a new version
>> mentionning that this proposal (if not already merged)
>> could be modified to use it.
>>
>
> I am introducing this proposal to provide a uniform pattern for
> polymorphic programming to avoid unnecessary redesign. For example, in
> `std::function`, there are member functions `target_type` and `operator
> bool()`; while in `std::any`, there are similar member functions `type` a=
nd
> `has_value` =E2=80=94 they actually has the same semantics.
>
> By the way, how would you specify a polymorphic executor using a
>>>> composition of several requirements (some might be custom), as the pro=
posal
>>>> requests?
>>>>
>>>
>>>
>> The "facade" are compatible to the C++ type system, including but not
>>> limited to inheritance, overloading, templates, and qualifiers. For
>>> example, we are able to define a facade template `Callable` to replace =
the
>>> class template `std::function`:
>>>
>>> template <class T>
>>> facade Callable; // undefined
>>>
>>> template <class R, class... Args>
>>> facade Callable<R(Args...)> {
>>> R operator(Args... args);
>>> };
>>>
>>> ... and we could define a series of facades for the executors:
>>>
>>> facade OneWayExecutor {
>>> void execute(static_proxy<Callable<void()>> f) const;
>>> };
>>>
>>> template <class T>
>>> facade TwoWayExecutor {
>>> std::experimental::future<T>
>>> twoway_execute(static_proxy<Callable<void()>> f) const;
>>> };
>>>
>>> ... and we can also define other facades based on them if necessary:
>>>
>>> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
>>> void wait_for_all_tasks_to_be_done_or_something();
>>> void reset_worker_count(std::size_t new_count);
>>> static std::string some_type_specific_description();
>>> };
>>>
>>>
>> This part is not what is needed. We need to be able to compose with
>> several requirements, not have to create another one.
>>
>
> Do you mean conjunction? In the example above, `MyExecutor` is a
> conjunction of `OneWayExecutor` and `TwoWayExecutor`.
>
> Providing there is a type `my_awesome_executor` meets the requirements
>>> defined by the facade, the following code shows its basic usage:
>>>
>>> const my_awesome_executor ex;
>>> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is
>>> not convertible to `non-const` reference;
>>> static_proxy<const MyExecutor&> p1(ex); // OK;
>>> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called=
;
>>> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructo=
r
>>> is called;
>>> std::cout << p3.type() << std::endl; // OK; Print the result of
>>> `typeid(my_awesome_executor)`;
>>> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value i=
s
>>> convertible to `const` reference;
>>> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;
>>> `non-volatile` value is convertible to `volatile` value;
>>> std::cout << p3.has_value() << std::endl; // OK; Print `false`, becaus=
e
>>> the value has been moved to `p5`;
>>> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // O=
K;
>>> p5.execute([] { std::cout << "Although bad things happen sometimes..."
>>> << std::endl; }); // Error; The `execute` function is not `volatile`;
>>>
>>>
>> Note that the current executor proposal to not necessarilly associate a
>> requirement to a specific interface. It would be possible
>> to have a requirement not change the interface (but change the semantic)=
..
>>
>
> I do not understand what you mean by this paragraph. Could you please
> clarify it?
>
And this is why you should've probably spent more time learning about the
proposal before trying to trash it.
>
> 4) Yes, it is minimal. The goal was never to specify a fully usable threa=
d
>>>>>> pool - only that some minimal structure be provided such that minima=
l
>>>>>> executors can be defined. Trying to specify a perfect thread pool, a=
ssuming
>>>>>> one to exist, would delay the executors specification for no gain.
>>>>>>
>>>>>
>>>>> If it is a minimal one, I think it should not support "wait" or "stop=
"
>>>>> operations, and should be MoveConstructible. More importantly, the
>>>>> destructor should be non-blocking.
>>>>>
>>>>>
>>>> I don't think that's possible.
>>>> There is a need, in my experience, for an explicit synchronization
>>>> point with all the underlying threads to be able to make sense of the
>>>> program.
>>>>
>>>
>>> I think that is what the users should concern about, not us. Users coul=
d
>>> use latches, futures or some other structural support utilities propose=
d in
>>> another paper of mine (P0642) to control the flow.
>>>
>>>
>>
>> How do you provide the user any control if they don't ajve access to wha=
t
>> is controlling the underlying thread?
>> Threads are resources, they have to be managed explicitely in some ways.
>> Hiding them from the user is good but they still need to know what some
>> will be created and where their lifetime will end.
>> Also, the user is usually concerned with the task, not the thread.
>>
>
> As I replied to Mysen, I think it is not necessary both for users and
> library implementators.
>
> For example in your following example, the tasks pushed in that thread
>>>> pool can survive the lifetime of the thread pool. That makes
>>>> reasoning almost impossible. To put it another way: it goes against
>>>> RAII principles and definitely is not the good way to go.
>>>>
>>>
>>> I do not understand how you come to the conclusion that "it goes agains=
t
>>> RAII principles". If my understanding is right, RAII is about "initiali=
zing
>>> the resource when it is acquired", and I did not find my code against t=
his
>>> principle. Is there anything I missed?
>>>
>>
>> RAII imply, more importantly, that the resources acquired are guaranteed
>> to be released in a deterministic way, when the destructor is called.
>> It's important to make sure that after you destroying the thread pool ,
>> there should be no thread from that thread pool still alive, otherwise i=
t
>> makes reasoning very hard.
>>
> Forcing either the user to call a function to end al the threads (maybe
>> returning a future, acting like a barrier), that must be called otherwis=
e
>> the thread pool destructor will call terminate
>> OR guarantee that we will not get out from the thread-pool destructor
>> until all the managed threads are joined,
>> are important variations of the guarantee needed to keep reasonning with
>> the resources possible.
>>
>
> I think if the thread pool is correctly used, the task queue shall always
> be empty when destroying the thread pool, and the resources (mutex, queue=
,
> etc.) would be released shortly after the destruction.
>
> Actually, this implementation could be abused if one does not have the
>>> ability to write concurrent programs correctly. This phenomenon is comm=
on
>>> in the whole C++ programming language, not only at this point.
>>>
>>>
>> I don't think it have anything to do with the other code. You explicitel=
y
>> make threads live longer than the thread pool without providing life
>> ownership to the user.
>> To me, it's some kind of thread leak. It might not hurt, but it will
>> confuse a lot. (I've been there) In particular when trying to reason abo=
ut
>> the user code. You are not sure when is finished what
>> just by reading the code.
>>
>
> I think this is a part of the difficulty of concurrent programming.
> However, the difficulty will not be reduced effectively by joining the
> threads, and will definitely reduce performance.
>
> Anyway, the proposal is not supposed to provide much in thread pools and
>>>> other proposals will provide these, in variety I suppose (or predict).
>>>>
>>>
>>> I will be grateful if you could provide any relevant information.
>>>
>>>
>>
>> Of course. It's mentioned in the design document, P0761R2 :
>> http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0761r2.pdf
>>
>> Here is the revelant part, in particular the last paragraph:
>>
>> "Thread Pool Variations. Our proposal specifies a single thread pool
>> type, static_thread_pool, which
>> represents a simple thread pool which assumes that the creator knows the
>> correct thread count for the use
>> case. As a result, it assumes a pre-determined sizing and does not
>> automatically resize itself and has no
>> default size.
>>
>> There exist heuristics for right-sizing a thread pool (both statically
>> determined like 2*std::thread::hardware
>> -_concurrency(), as well as dynamically adjusted), but these are
>> considered to be out of scope of this
>> proposal as a reasonable size pool is specific to the application and
>> hardware.
>>
>> We recognize that alternative approaches serving other use cases exist
>> and anticipate additional thread pool
>> proposals. In particular, we are aware of a separate effort which will
>> propose an additional thread pool type,
>> dynamic_thread_pool, and we expect this type of thread pool to be both
>> dynamically and automatically
>> resizable."
>>
>> So basically, there are other thread pool/execution context proposals on
>> the work, apparently.
>> I just don't know who is working on them. Maybe you can provide some
>> yourself, it can be separate proposals.
>>
>
> Actually, I have implemented various of thread pools on different
> platforms with different mechanisms (as I mentioned, bounded queue,
> keep-alive duration, threads with attributes, work-stealing, timing,
> merging, etc.), but I have not finished related technical specifications
> that reasonable and motivating enough yet.
>
> I would appreciate it if you could provide a better implementation and
>>> benchmark.
>>>
>>
>> Well, all performant thread pools I know of use "work-stealing"
>> algorithms which imply having 1 queue per thread
>> and the algorithm re-equilibrate the workload depending on some
>> parametters. I understand it is not trivial
>> and didn't attempt to implement one (in critical cases I would do like
>> you, a "naive but working" one).
>>
>> For example of such implementations, look at:
>> - Intel Threading Building Blocks;
>> - HPX;
>> - maybe Boost.Thread experimental thread pool do work stealing, I'm not
>> sure, I didn't check.
>>
>
> As far as I am concered, "work-stealing" strategy is useful almost only
> when there are a lot of `wait` in our original code, and we want to
> reconstruct them within a short period to increase performance. However,
> "work-stealing" strategy is usually inefficient in well-design algorithms=
..
>
> I also recommend checking this talk from Sean Parent clarifying the issue
>> with the code you provided: https://www.youtube.com/watch?v=3DzULU6Hhp42=
w
>> Also "C++ Concurrency In Action" book clarify the details of all that,
>> and if you didn't read it and the subject
>> is interesting to you, it would be very interesting for you.
>>
>
> Thank you for the recommendations. I will check it out.
>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit
> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc=
1-44ca-822b-19d512d71309%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/484c23da-2c=
c1-44ca-822b-19d512d71309%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoot=
er>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAPCFJdRsoJkON40E4CJ_CUv_snGczDM1bA3QOo5TrF9JW%3=
DV7OQ%40mail.gmail.com.
--001a114db1107025cb0568f14a4f
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br><div class=3D"gmail_quote"><div dir=3D"ltr">On Tue=
, Apr 3, 2018 at 11:58 AM Mingxin Wang <<a href=3D"mailto:wmx16835vv@163=
..com">wmx16835vv@163.com</a>> wrote:<br></div><blockquote class=3D"gmail=
_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:=
1ex"><div dir=3D"ltr">On Tuesday, April 3, 2018 at 5:31:43 AM UTC+8, Klaim =
- Jo=C3=ABl Lamotte wrote:<blockquote class=3D"gmail_quote" style=3D"margin=
:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=
=3D"ltr"><div><div class=3D"gmail_quote"><div>I know (if I remember correct=
ly I'm one of the commenters mentionned in it).</div></div></div></div>=
</blockquote><div><br></div></div><div dir=3D"ltr"><div>Thank you again for=
your valuable comments! Your name is in the "Acknowledgement" pa=
rt in P0957.</div></div><div dir=3D"ltr"><div>=C2=A0</div><blockquote class=
=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc s=
olid;padding-left:1ex"><div dir=3D"ltr"><div><div class=3D"gmail_quote"><di=
v>But that's not my point. The point, (as mysen clarified) is that if y=
our proposal provide a way to implement this polymorphic executor,</div><di=
v>it's not necessary to mention it in the proposal because it would be =
an implementation detail.</div><div>I also agree with mysen that it would n=
eed to accept types, not "facades" to work as specified.</div></d=
iv></div></div></blockquote><div><br></div></div><div dir=3D"ltr"><div>Faca=
des are types, and could be used like any other placeholder types in C++.</=
div></div><div dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quote"=
style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-lef=
t:1ex"><div dir=3D"ltr"><div><div class=3D"gmail_quote"><div>Anyway your pr=
oposal is not in a position to be relied upon right now, it's too early=
.. But if it get traction, maybe propose a new version mentionning that this=
proposal (if not already merged)</div><div>could be modified to use it.</d=
iv></div></div></div></blockquote><div><br></div></div><div dir=3D"ltr"><di=
v>I am introducing this proposal to provide a uniform pattern for polymorph=
ic programming to avoid unnecessary redesign. For example, in `std::functio=
n`, there are member functions `target_type` and `operator bool()`; while i=
n `std::any`, there are similar member functions `type` and `has_value` =E2=
=80=94 they actually has the same semantics.</div></div><div dir=3D"ltr"><d=
iv><br></div><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-lef=
t:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div =
class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"margin:0px=
0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><di=
v dir=3D"ltr"><span><blockquote class=3D"gmail_quote" style=3D"margin:0px 0=
px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div =
dir=3D"ltr"><div class=3D"gmail_quote">By the way, how would=C2=A0 you spec=
ify a polymorphic executor using a composition of several requirements (som=
e might be custom), as the proposal requests?</div></div></blockquote><div>=
=C2=A0<br></div></span></div></blockquote><blockquote class=3D"gmail_quote"=
style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);p=
adding-left:1ex"><div dir=3D"ltr"><span><div></div></span><div>The "fa=
cade" are compatible to the C++ type system, including but not limited=
to inheritance, overloading, templates, and qualifiers. For example, we ar=
e able to define a facade template `Callable` to replace the class template=
`std::function`:</div><div><br></div><div><div style=3D"border-width:1px;b=
order-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,25=
0,250);word-wrap:break-word"><code><div><font color=3D"#660066"><div>templa=
te <class T></div><div>facade Callable; =C2=A0// undefined</div><div>=
<br></div><div>template <class R, class... Args></div><div>facade Cal=
lable<R(Args...)> {</div><div>=C2=A0 R operator(Args... args);</div><=
div>};</div></font></div></code></div><br>... and we could define a series =
of facades for the executors:</div><div><br></div><div><div style=3D"border=
-width:1px;border-style:solid;border-color:rgb(187,187,187);background-colo=
r:rgb(250,250,250);word-wrap:break-word"><code><div><font color=3D"#660066"=
><div>facade OneWayExecutor {</div><div>=C2=A0 void execute(static_proxy<=
;Callable<void()>> f) const;</div><div>};</div><div><br></div><div=
>template <class T></div><div>facade TwoWayExecutor {</div><div>=C2=
=A0 std::experimental::future<T> twoway_execute(static_proxy<Calla=
ble<void()>> f) const;</div><div>};</div></font></div></code></div=
><br>... and we can also define other facades based on them if necessary:</=
div><div><br></div><div><div style=3D"border-width:1px;border-style:solid;b=
order-color:rgb(187,187,187);background-color:rgb(250,250,250);word-wrap:br=
eak-word"><code><div><div><div>facade MyExecutor : OneWayExecutor, TwoWayEx=
ecutor {</div><div>=C2=A0 void wait_for_all_tasks_to_be_done_or_something()=
;</div><div>=C2=A0 void reset_worker_count(std::size_t new_count);</div><di=
v>=C2=A0 static std::string some_type_specific_description();</div><div>};<=
/div></div></div></code></div><br></div></div></blockquote><div><br></div><=
div>This part is not what is needed. We need to be able to compose with sev=
eral requirements, not have to create another one.</div></div></div></block=
quote><div><br></div></div><div dir=3D"ltr"><div>Do you mean=C2=A0conjuncti=
on? In the example above, `MyExecutor` is a conjunction of `OneWayExecutor`=
and `TwoWayExecutor`.</div></div><div dir=3D"ltr"><div><br></div><blockquo=
te class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1p=
x #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote">=
<blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-=
left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div>Pro=
viding there is a type `my_awesome_executor` meets the requirements defined=
by the facade, the following code shows its basic usage:</div><div><br></d=
iv><div><div style=3D"background-color:rgb(250,250,250);border-color:rgb(18=
7,187,187);border-style:solid;border-width:1px;word-wrap:break-word"><code>=
<div><div>const my_awesome_executor ex;</div><div>static_proxy<MyExecuto=
r&> p0(ex); =C2=A0// Error; Because `const` value is not convertible=
to `non-const` reference;</div><div>static_proxy<const MyExecutor&&=
gt; p1(ex); =C2=A0// OK;</div><div>static_proxy<MyExecutor> p2(ex); =
=C2=A0// OK; The copy-constructor is called;</div><div>static_proxy<MyEx=
ecutor> p3(std::move(ex)); =C2=A0// OK; The move-constructor is called;<=
/div><div>std::cout << p3.type() << std::endl; =C2=A0// OK; Pri=
nt the result of `typeid(my_awesome_executor)`;</div><div>static_proxy<c=
onst OneWayExecutor&> p4(p2); =C2=A0// OK; `non-const` value is conv=
ertible to `const` reference;</div><div>static_proxy<volatile MyExecutor=
> p5(std::move(p3)); =C2=A0// OK; `non-volatile` value is convertible to=
`volatile` value;</div><div>std::cout << p3.has_value() << std=
::endl; =C2=A0// OK; Print `false`, because the value has been moved to `p5=
`;</div><div>p4.execute([] { std::cout << "Life is so cool!"=
; << std::endl; }); =C2=A0// OK;</div><div>p5.execute([] { std::cout =
<< "Although bad things happen sometimes..." << std::=
endl; }); =C2=A0// Error; The `execute` function is not `volatile`;</div></=
div></code></div></div><span><div><br></div></span></div></blockquote><div>=
<br></div><div>Note that the current executor proposal to not necessarilly =
associate a requirement to a specific interface. It would be possible</div>=
<div>to have a requirement not change the interface (but change the semanti=
c).</div></div></div></blockquote><div><br></div></div><div dir=3D"ltr"><di=
v>I do not understand what you mean by this=C2=A0paragraph. Could you pleas=
e clarify it?</div></div></blockquote><div><br></div><div>And this is why y=
ou should've probably spent more time learning about the proposal befor=
e trying to trash it.</div><div>=C2=A0</div><blockquote class=3D"gmail_quot=
e" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">=
<div dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quote" style=3D"=
margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><di=
v dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" =
style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);pa=
dding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" st=
yle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padd=
ing-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=
=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rg=
b(204,204,204);padding-left:1ex"><div dir=3D"ltr"><blockquote class=3D"gmai=
l_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,20=
4,204);padding-left:1ex"><div dir=3D"ltr">4) Yes, it is minimal. The goal w=
as never to specify a fully usable thread pool - only that some minimal str=
ucture be provided such that minimal executors can be defined. Trying to sp=
ecify a perfect thread pool, assuming one to exist, would delay the executo=
rs specification for no gain. =C2=A0</div></blockquote><div><br></div><div>=
If it is a minimal one, I think it should not support "wait" or &=
quot;stop" operations, and should be MoveConstructible. More important=
ly, the destructor should be non-blocking.</div><div><br></div></div></bloc=
kquote><div><br></div><div>I don't think that's possible.</div><div=
>There is a need, in my experience, for an explicit synchronization point w=
ith all the underlying threads to be able to make sense of the program.</di=
v></div></div></blockquote><div><br></div></span><div>I think that is what =
the users should concern about, not us. Users could use latches, futures or=
some other structural support utilities proposed in another paper of mine =
(P0642) to control the flow.</div><span><div>=C2=A0</div></span></div></blo=
ckquote><div><br></div><div>How do you provide the user any control if they=
don't ajve access to what is controlling the underlying thread?</div><=
div>Threads are resources, they have to be managed explicitely in some ways=
.. Hiding them from the user is good but they still need to know what some w=
ill be created and where their lifetime will end.</div><div>Also, the user =
is usually concerned with the task, not the thread.</div></div></div></bloc=
kquote><div><br></div></div><div dir=3D"ltr"><div>As I replied to=C2=A0Myse=
n, I think it is not necessary both for users and library implementators.</=
div></div><div dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quote"=
style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-lef=
t:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gma=
il_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,2=
04,204);padding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail=
_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204=
,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>Fo=
r example in your following example, the tasks pushed in that thread pool c=
an survive the lifetime of the thread pool. That makes=C2=A0</div><div>reas=
oning almost impossible. To put it another way: it goes against RAII princi=
ples and definitely is not the good way to go.</div></div></div></blockquot=
e><div><br></div></span><div>I do not understand how you come to the conclu=
sion that "it goes against RAII principles". If my understanding =
is right, RAII is about "initializing the resource when it is acquired=
", and I did not find my code against this principle. Is there anythin=
g I missed?</div></div></blockquote><div><br></div><div>RAII imply, more im=
portantly, that the resources acquired are guaranteed to be released in a d=
eterministic way, when the destructor is called.</div><div>It's importa=
nt to make sure that after you destroying=C2=A0 the thread pool , there sho=
uld be no thread from that thread pool still alive, otherwise it makes reas=
oning very hard.</div></div></div></blockquote><blockquote class=3D"gmail_q=
uote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;paddin=
g-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>Forcing either=
the user to call a function to end al the threads (maybe returning a futur=
e, acting like a barrier), that must be called otherwise the thread pool de=
structor will call terminate</div><div>OR guarantee that we will not get ou=
t from the thread-pool destructor until all the managed threads are joined,=
</div><div>are important variations of the guarantee needed to keep reasonn=
ing with the resources possible.</div></div></div></blockquote><div><br></d=
iv></div><div dir=3D"ltr"><div>I think if the thread pool is correctly used=
, the task queue shall always be empty when destroying the thread pool, and=
the resources (mutex, queue, etc.) would be released shortly after the des=
truction.</div></div><div dir=3D"ltr"><div><br></div><blockquote class=3D"g=
mail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;=
padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote c=
lass=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px soli=
d rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>Actua=
lly, this implementation could be abused if one does not have the ability t=
o write concurrent programs correctly. This=C2=A0phenomenon is common in th=
e whole C++ programming language, not only at this point.</div><span><div><=
br></div></span></div></blockquote><div><br></div><div>I don't think it=
have anything to do with the other code. You explicitely make threads live=
longer than the thread pool without providing life ownership to the user.<=
/div><div>To me, it's some kind of thread leak. It might not hurt, but =
it will confuse a lot. (I've been there) In particular when trying to r=
eason about the user code. You are not sure when is finished what</div><div=
>just by reading the code.</div></div></div></blockquote><div><br></div></d=
iv><div dir=3D"ltr"><div>I think this is a part of the difficulty of concur=
rent programming. However, the difficulty will not be reduced effectively b=
y joining the threads, and will definitely reduce performance.</div></div><=
div dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quote" style=3D"m=
argin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div=
dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" s=
tyle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);pad=
ding-left:1ex"><div dir=3D"ltr"><span><div></div><blockquote class=3D"gmail=
_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204=
,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>An=
yway, the proposal is not supposed to provide much in thread pools and othe=
r proposals will provide these, in variety I suppose (or predict).</div></d=
iv></div></blockquote><div><br></div></span><div>I will be grateful if you =
could provide any relevant information.<br></div><div><div><div>=C2=A0</div=
></div></div></div></blockquote><div><br></div><div>Of course. It's men=
tioned in the design document,=C2=A0P0761R2 :=C2=A0<a href=3D"http://www.op=
en-std.org/jtc1/sc22/wg21/docs/papers/2018/p0761r2.pdf" rel=3D"nofollow" ta=
rget=3D"_blank">http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p07=
61r2.pdf</a></div><div><br></div><div>Here is the revelant part, in particu=
lar the last paragraph:</div><div><br></div><div><div>"Thread Pool Var=
iations. Our proposal specifies a single thread pool type, static_thread_po=
ol, which</div><div>represents a simple thread pool which assumes that the =
creator knows the correct thread count for the use</div><div>case. As a res=
ult, it assumes a pre-determined sizing and does not automatically resize i=
tself and has no</div><div>default size.</div><div><br></div><div>There exi=
st heuristics for right-sizing a thread pool (both statically determined li=
ke 2*std::thread::hardware</div><div>-_concurrency(), as well as dynamicall=
y adjusted), but these are considered to be out of scope of this</div><div>=
proposal as a reasonable size pool is specific to the application and hardw=
are.</div><div><br></div><div>We recognize that alternative approaches serv=
ing other use cases exist and anticipate additional thread pool</div><div>p=
roposals. In particular, we are aware of a separate effort which will propo=
se an additional thread pool type,</div><div>dynamic_thread_pool, and we ex=
pect this type of thread pool to be both dynamically and automatically</div=
><div>resizable."</div></div><div><br></div><div>So basically, there a=
re other thread pool/execution context proposals on the work, apparently.</=
div><div>I just don't know who is working on them. Maybe you can provid=
e some yourself, it can be separate proposals.</div></div></div></blockquot=
e><div><br></div></div><div dir=3D"ltr"><div>Actually, I have implemented v=
arious of thread pools on different platforms with different mechanisms (as=
I mentioned, bounded queue, keep-alive duration, threads with attributes, =
work-stealing, timing, merging, etc.), but I have not finished related=C2=
=A0technical specifications that reasonable and=C2=A0motivating enough yet.=
</div></div><div dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quot=
e" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-l=
eft:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"g=
mail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204=
,204,204);padding-left:1ex"><div dir=3D"ltr"><div>I would appreciate it if =
you could provide a better implementation and benchmark.</div></div></block=
quote><div><br></div><div>Well, all performant thread pools I know of use &=
quot;work-stealing" algorithms which imply having 1 queue per thread</=
div><div>and the algorithm re-equilibrate the workload depending on some pa=
rametters. I understand it is not trivial</div><div>and didn't attempt =
to implement one (in critical cases I would do like you, a "naive but =
working" one).</div><div><br></div><div>For example of such implementa=
tions, look at:</div><div>=C2=A0- Intel Threading Building Blocks;</div><di=
v>=C2=A0- HPX;</div><div>=C2=A0- maybe Boost.Thread experimental thread poo=
l do work stealing, I'm not sure, I didn't check.</div></div></div>=
</blockquote><div><br></div></div><div dir=3D"ltr"><div>As far as I am conc=
ered, "work-stealing" strategy is useful almost only when there a=
re a lot of `wait` in our original code, and we want to reconstruct them wi=
thin a short period to increase performance. However, "work-stealing&q=
uot; strategy=C2=A0is usually inefficient in well-design algorithms.</div><=
/div><div dir=3D"ltr"><div><br></div><blockquote class=3D"gmail_quote" styl=
e=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex=
"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>I also recommend checkin=
g this talk from Sean Parent clarifying the issue with the code you provide=
d:=C2=A0<a href=3D"https://www.youtube.com/watch?v=3DzULU6Hhp42w" rel=3D"no=
follow" target=3D"_blank">https://www.youtube.com/watch?v=3DzULU6Hhp42w</a>=
</div><div>Also "C++ Concurrency In Action" book clarify the deta=
ils of all that, and if you didn't read it and the subject</div><div>is=
interesting to you, it would be very interesting for you.</div></div></div=
></blockquote><div><br></div></div><div dir=3D"ltr"><div>Thank you for the=
=C2=A0recommendations.=C2=A0I will check it out.</div></div>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-=
44ca-822b-19d512d71309%40isocpp.org</a>.<br>
</blockquote></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAPCFJdRsoJkON40E4CJ_CUv_snGczDM1bA3Q=
Oo5TrF9JW%3DV7OQ%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdRsoJkON4=
0E4CJ_CUv_snGczDM1bA3QOo5TrF9JW%3DV7OQ%40mail.gmail.com</a>.<br />
--001a114db1107025cb0568f14a4f--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Tue, 3 Apr 2018 07:03:47 -0700 (PDT)
Raw View
------=_Part_21557_1890037259.1522764227545
Content-Type: multipart/alternative;
boundary="----=_Part_21558_1340296698.1522764227545"
------=_Part_21558_1340296698.1522764227545
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Tuesday, April 3, 2018 at 9:00:31 PM UTC+8, Micha=C5=82 Dominiak wrote:
>
> On Tue, Apr 3, 2018 at 11:58 AM Mingxin Wang <wmx16...@163.com=20
> <javascript:>> wrote:
>
>> On Tuesday, April 3, 2018 at 5:31:43 AM UTC+8, Klaim - Jo=C3=ABl Lamotte=
wrote:
>>
>>> Note that the current executor proposal to not necessarilly associate a=
=20
>>> requirement to a specific interface. It would be possible
>>> to have a requirement not change the interface (but change the semantic=
).
>>>
>>
>> I do not understand what you mean by this paragraph. Could you please=20
>> clarify it?
>>
>
> And this is why you should've probably spent more time learning about the=
=20
> proposal before trying to trash it.
>
Maybe I did miss something. However, I am still not clear about the=20
statement "not necessarilly associate a requirement to a specific=20
interface" after studying the proposal further. If it is targeting the=20
expression `static_proxy<Callable<void()>>`, we could also change the=20
facade `OneWayExecutor` into a facade template if necessary (maybe with the=
=20
Concepts TS):
template <class Callable>
facade OneWayExecutor {
void execute(Callable c) const;
};
If my understanding is incorrect, could you please clarify the situation?
Thank you!
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/2ce9cc8e-547f-49b1-8073-5972c804a46a%40isocpp.or=
g.
------=_Part_21558_1340296698.1522764227545
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Tuesday, April 3, 2018 at 9:00:31 PM UTC+8, Micha=C5=82=
Dominiak wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin=
-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"lt=
r"><div class=3D"gmail_quote"><div dir=3D"ltr">On Tue, Apr 3, 2018 at 11:58=
AM Mingxin Wang <<a href=3D"javascript:" target=3D"_blank" gdf-obfuscat=
ed-mailto=3D"dDqB4lOCBQAJ" rel=3D"nofollow" onmousedown=3D"this.href=3D'=
;javascript:';return true;" onclick=3D"this.href=3D'javascript:'=
;;return true;">wmx16...@163.com</a>> wrote:<br></div><blockquote class=
=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padd=
ing-left:1ex"><div dir=3D"ltr">On Tuesday, April 3, 2018 at 5:31:43 AM UTC+=
8, Klaim - Jo=C3=ABl Lamotte wrote:</div><div dir=3D"ltr"><blockquote class=
=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc s=
olid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>Not=
e that the current executor proposal to not necessarilly associate a requir=
ement to a specific interface. It would be possible</div><div>to have a req=
uirement not change the interface (but change the semantic).</div></div></d=
iv></blockquote><div><br></div></div><div dir=3D"ltr"><div>I do not underst=
and what you mean by this=C2=A0paragraph. Could you please clarify it?</div=
></div></blockquote><div><br></div><div>And this is why you should've p=
robably spent more time learning about the proposal before trying to trash =
it.</div></div></div></blockquote><div><br></div><div>Maybe I did miss some=
thing. However, I am still not clear about the statement "not necessar=
illy associate a requirement to a specific interface" after studying t=
he proposal further. If it is targeting the expression `static_proxy<Cal=
lable<void()>>`, we could also change the facade `OneWayExecutor` =
into a facade template if necessary (maybe with the Concepts TS):</div><div=
><br></div><div><div class=3D"prettyprint" style=3D"background-color: rgb(2=
50, 250, 250); border-color: rgb(187, 187, 187); border-style: solid; borde=
r-width: 1px; word-wrap: break-word;"><code class=3D"prettyprint"><div clas=
s=3D"subprettyprint"><div class=3D"subprettyprint">template <class Calla=
ble></div><div class=3D"subprettyprint">facade OneWayExecutor {</div><di=
v class=3D"subprettyprint">=C2=A0 void execute(Callable c) const;</div><div=
class=3D"subprettyprint">};</div></div></code></div><br>If my understandin=
g is incorrect, could you please clarify the situation?</div><div><br></div=
><div>Thank you!</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/2ce9cc8e-547f-49b1-8073-5972c804a46a%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/2ce9cc8e-547f-49b1-8073-5972c804a46a=
%40isocpp.org</a>.<br />
------=_Part_21558_1340296698.1522764227545--
------=_Part_21557_1890037259.1522764227545--
.
Author: =?UTF-8?Q?Klaim_=2D_Jo=C3=ABl_Lamotte?= <mjklaim@gmail.com>
Date: Tue, 3 Apr 2018 18:11:26 +0200
Raw View
--000000000000c4a7ff0568f3f7e1
Content-Type: text/plain; charset="UTF-8"
On 3 April 2018 at 11:58, Mingxin Wang <wmx16835vv@163.com> wrote:
>
>
>>>> ... and we can also define other facades based on them if necessary:
>>>
>>> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
>>> void wait_for_all_tasks_to_be_done_or_something();
>>> void reset_worker_count(std::size_t new_count);
>>> static std::string some_type_specific_description();
>>> };
>>>
>>>
>> This part is not what is needed. We need to be able to compose with
>> several requirements, not have to create another one.
>>
>
> Do you mean conjunction? In the example above, `MyExecutor` is a
> conjunction of `OneWayExecutor` and `TwoWayExecutor`.
>
>
I see, I misread assuming MyExecutor was a conjonction of both requirements
instead of an actual executor.
> Providing there is a type `my_awesome_executor` meets the requirements
>>> defined by the facade, the following code shows its basic usage:
>>>
>>> const my_awesome_executor ex;
>>> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is
>>> not convertible to `non-const` reference;
>>> static_proxy<const MyExecutor&> p1(ex); // OK;
>>> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is called;
>>> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The move-constructor
>>> is called;
>>> std::cout << p3.type() << std::endl; // OK; Print the result of
>>> `typeid(my_awesome_executor)`;
>>> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value is
>>> convertible to `const` reference;
>>> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;
>>> `non-volatile` value is convertible to `volatile` value;
>>> std::cout << p3.has_value() << std::endl; // OK; Print `false`, because
>>> the value has been moved to `p5`;
>>> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); // OK;
>>> p5.execute([] { std::cout << "Although bad things happen sometimes..."
>>> << std::endl; }); // Error; The `execute` function is not `volatile`;
>>>
>>>
>> Note that the current executor proposal to not necessarilly associate a
>> requirement to a specific interface. It would be possible
>> to have a requirement not change the interface (but change the semantic).
>>
>
> I do not understand what you mean by this paragraph. Could you please
> clarify it?
>
This is my understanding of the current executor proposal, so maybe I'm
wrong but let's say that I want to introduce a new type of requirement:
struct MaybeOnline {};
I do not necessarilly have a specific interface that an executor must
provide. It might just expose a tag type to be discernable.
It might not introduce a member function, to be clear.
Just wanted that to be clear. The prerequisite types does not seem to be
interfaces themselves, they seem to be tags implying interfaces.
>
> 4) Yes, it is minimal. The goal was never to specify a fully usable thread
>>>>>> pool - only that some minimal structure be provided such that minimal
>>>>>> executors can be defined. Trying to specify a perfect thread pool, assuming
>>>>>> one to exist, would delay the executors specification for no gain.
>>>>>>
>>>>>
>>>>> If it is a minimal one, I think it should not support "wait" or "stop"
>>>>> operations, and should be MoveConstructible. More importantly, the
>>>>> destructor should be non-blocking.
>>>>>
>>>>>
>>>> I don't think that's possible.
>>>> There is a need, in my experience, for an explicit synchronization
>>>> point with all the underlying threads to be able to make sense of the
>>>> program.
>>>>
>>>
>>> I think that is what the users should concern about, not us. Users could
>>> use latches, futures or some other structural support utilities proposed in
>>> another paper of mine (P0642) to control the flow.
>>>
>>>
>>
>> How do you provide the user any control if they don't ajve access to what
>> is controlling the underlying thread?
>> Threads are resources, they have to be managed explicitely in some ways.
>> Hiding them from the user is good but they still need to know what some
>> will be created and where their lifetime will end.
>> Also, the user is usually concerned with the task, not the thread.
>>
>
> As I replied to Mysen, I think it is not necessary both for users and
> library implementators.
>
>
That do not match my experience, but maybe there is need for both.
> For example in your following example, the tasks pushed in that thread
>>>> pool can survive the lifetime of the thread pool. That makes
>>>> reasoning almost impossible. To put it another way: it goes against
>>>> RAII principles and definitely is not the good way to go.
>>>>
>>>
>>> I do not understand how you come to the conclusion that "it goes against
>>> RAII principles". If my understanding is right, RAII is about "initializing
>>> the resource when it is acquired", and I did not find my code against this
>>> principle. Is there anything I missed?
>>>
>>
>> RAII imply, more importantly, that the resources acquired are guaranteed
>> to be released in a deterministic way, when the destructor is called.
>> It's important to make sure that after you destroying the thread pool ,
>> there should be no thread from that thread pool still alive, otherwise it
>> makes reasoning very hard.
>>
> Forcing either the user to call a function to end al the threads (maybe
>> returning a future, acting like a barrier), that must be called otherwise
>> the thread pool destructor will call terminate
>> OR guarantee that we will not get out from the thread-pool destructor
>> until all the managed threads are joined,
>> are important variations of the guarantee needed to keep reasonning with
>> the resources possible.
>>
>
> I think if the thread pool is correctly used, the task queue shall always
> be empty when destroying the thread pool, and the resources (mutex, queue,
> etc.) would be released shortly after the destruction.
>
>
We agree on this, though by nature we can't garantee that without some way
to provide a synchronization mechanism to the user, sync of the end of all
the resources/threads.
As we can't return a future from the destructor, there is not much we can
do to provide this guarantee.
> Actually, this implementation could be abused if one does not have the
>>> ability to write concurrent programs correctly. This phenomenon is common
>>> in the whole C++ programming language, not only at this point.
>>>
>>>
>> I don't think it have anything to do with the other code. You explicitely
>> make threads live longer than the thread pool without providing life
>> ownership to the user.
>> To me, it's some kind of thread leak. It might not hurt, but it will
>> confuse a lot. (I've been there) In particular when trying to reason about
>> the user code. You are not sure when is finished what
>> just by reading the code.
>>
>
> I think this is a part of the difficulty of concurrent programming.
> However, the difficulty will not be reduced effectively by joining the
> threads, and will definitely reduce performance.
>
>
It is indeed. What I mean is that if all your construct have clear resource
lifetime semantics, it's actually far easier (without any need for impact
performance) to reason about concurrent code.
This is what I've been experimenting with with great results.
> So basically, there are other thread pool/execution context proposals on
>> the work, apparently.
>> I just don't know who is working on them. Maybe you can provide some
>> yourself, it can be separate proposals.
>>
>
> Actually, I have implemented various of thread pools on different
> platforms with different mechanisms (as I mentioned, bounded queue,
> keep-alive duration, threads with attributes, work-stealing, timing,
> merging, etc.), but I have not finished related technical specifications
> that reasonable and motivating enough yet.
>
>
You probably have enough background to make some proposals in this
direction. Maybe contact Micheal Wong to see if you can help with the other
potential thread-pool and executors proposals.
> I would appreciate it if you could provide a better implementation and
>>> benchmark.
>>>
>>
>> Well, all performant thread pools I know of use "work-stealing"
>> algorithms which imply having 1 queue per thread
>> and the algorithm re-equilibrate the workload depending on some
>> parametters. I understand it is not trivial
>> and didn't attempt to implement one (in critical cases I would do like
>> you, a "naive but working" one).
>>
>> For example of such implementations, look at:
>> - Intel Threading Building Blocks;
>> - HPX;
>> - maybe Boost.Thread experimental thread pool do work stealing, I'm not
>> sure, I didn't check.
>>
>
> As far as I am concered, "work-stealing" strategy is useful almost only
> when there are a lot of `wait` in our original code, and we want to
> reconstruct them within a short period to increase performance. However,
> "work-stealing" strategy is usually inefficient in well-design algorithms.
>
>
My understanding is totally different: work-stealing does the workload
balance for threads in more efficient way than simpler algorithms for
managing task queues. It have nothing to do with waiting, but it does have
to do with the
unpredictable nature of execution time of varied kinds of work (so it's
helful even when task implementors persist with waiting).
It works well in the case we don't know what tasks will be executed and
when. This is why most general-purpose thread-pools are using some variant
of work-stealing (as showed in the talk video).
So if you are in a specialized case where tasks are very specific (like,
all the same with different parametters), then it's indeed less optimal
than a specific executor/thread-pool etc.
> I also recommend checking this talk from Sean Parent clarifying the issue
>> with the code you provided: https://www.youtube.com/watch?v=zULU6Hhp42w
>> Also "C++ Concurrency In Action" book clarify the details of all that,
>> and if you didn't read it and the subject
>> is interesting to you, it would be very interesting for you.
>>
>
> Thank you for the recommendations. I will check it out.
>
--
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-
> 822b-19d512d71309%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309%40isocpp.org?utm_medium=email&utm_source=footer>
> .
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OODTLK7KWcrBQxCE62LWkfitw%3Dp6rim%3DQRHBJrNwqj7Mg%40mail.gmail.com.
--000000000000c4a7ff0568f3f7e1
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 3 April 2018 at 11:58, Mingxin Wang <span dir=3D"ltr"><<a href=3D=
"mailto:wmx16835vv@163.com" target=3D"_blank">wmx16835vv@163.com</a>></s=
pan> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex=
;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span class=
=3D""><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin:0;ma=
rgin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"lt=
r"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"ma=
rgin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:=
1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" style=3D"marg=
in:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1e=
x"><div dir=3D"ltr"><div class=3D"gmail_quote"><br></div></div></blockquote=
></span></div></blockquote><blockquote class=3D"gmail_quote" style=3D"margi=
n:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex=
"><div dir=3D"ltr"><div>... and we can also define other facades based on t=
hem if necessary:</div><div><br></div><div><div style=3D"border-width:1px;b=
order-style:solid;border-color:rgb(187,187,187);background-color:rgb(250,25=
0,250);word-wrap:break-word"><code><div><div><div>facade MyExecutor : OneWa=
yExecutor, TwoWayExecutor {</div><div>=C2=A0 void wait_for_all_tasks_to_be_=
done_<wbr>or_something();</div><div>=C2=A0 void reset_worker_count(std::siz=
e_t new_count);</div><div>=C2=A0 static std::string some_type_specific_desc=
ription<wbr>();</div><div>};</div></div></div></code></div><br></div></div>=
</blockquote><div><br></div><div>This part is not what is needed. We need t=
o be able to compose with several requirements, not have to create another =
one.</div></div></div></blockquote><div><br></div></span><div>Do you mean=
=C2=A0conjunction? In the example above, `MyExecutor` is a conjunction of `=
OneWayExecutor` and `TwoWayExecutor`.</div><span class=3D""><div><br></div>=
</span></div></blockquote><div><br></div><div>I see, I misread assuming MyE=
xecutor was a conjonction of both requirements instead of an actual executo=
r.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:=
0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><s=
pan class=3D""><div></div><blockquote class=3D"gmail_quote" style=3D"margin=
:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=
=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=
=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding=
-left:1ex"><div dir=3D"ltr"><div>Providing there is a type `my_awesome_exec=
utor` meets the requirements defined by the facade, the following code show=
s its basic usage:</div><div><br></div><div><div style=3D"background-color:=
rgb(250,250,250);border-color:rgb(187,187,187);border-style:solid;border-wi=
dth:1px;word-wrap:break-word"><code><div><div>const my_awesome_executor ex;=
</div><div>static_proxy<MyExecutor&> p0(ex); =C2=A0// Error; Beca=
use `const` value is not convertible to `non-const` reference;</div><div>st=
atic_proxy<const MyExecutor&> p1(ex); =C2=A0// OK;</div><div>stat=
ic_proxy<MyExecutor> p2(ex); =C2=A0// OK; The copy-constructor is cal=
led;</div><div>static_proxy<MyExecutor> p3(std::move(ex)); =C2=A0// O=
K; The move-constructor is called;</div><div>std::cout << p3.type() &=
lt;< std::endl; =C2=A0// OK; Print the result of `typeid(my_awesome_exec=
utor)`;</div><div>static_proxy<const OneWayExecutor&> p4(p2); =C2=
=A0// OK; `non-const` value is convertible to `const` reference;</div><div>=
static_proxy<volatile MyExecutor> p5(std::move(p3)); =C2=A0// OK; `no=
n-volatile` value is convertible to `volatile` value;</div><div>std::cout &=
lt;< p3.has_value() << std::endl; =C2=A0// OK; Print `false`, beca=
use the value has been moved to `p5`;</div><div>p4.execute([] { std::cout &=
lt;< "Life is so cool!" << std::endl; }); =C2=A0// OK;</=
div><div>p5.execute([] { std::cout << "Although bad things happe=
n sometimes..." << std::endl; }); =C2=A0// Error; The `execute` =
function is not `volatile`;</div></div></code></div></div><span><div><br></=
div></span></div></blockquote><div><br></div><div>Note that the current exe=
cutor proposal to not necessarilly associate a requirement to a specific in=
terface. It would be possible</div><div>to have a requirement not change th=
e interface (but change the semantic).</div></div></div></blockquote><div><=
br></div></span><div>I do not understand what you mean by this=C2=A0paragra=
ph. Could you please clarify it?</div></div></blockquote><div><br></div><di=
v>This is my understanding of the current executor proposal, so maybe I'=
;m wrong but let's say that I want to introduce a new type of requireme=
nt:</div><div><br></div><div>struct MaybeOnline {};=C2=A0</div><div><br></d=
iv><div>I do not necessarilly have a specific interface that an executor mu=
st provide. It might just expose a tag type to be discernable.</div><div>It=
might not introduce a member function, to be clear.</div><div><br></div><d=
iv>Just wanted that to be clear. The prerequisite types does not seem to be=
interfaces themselves, they seem to be tags implying interfaces.</div><div=
>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;b=
order-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span class=3D=
""><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin:0;margi=
n-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr">=
<div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"margi=
n:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex=
"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" style=3D"margin:=
0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex">=
<div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quot=
e" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204)=
;padding-left:1ex"><div dir=3D"ltr"><blockquote class=3D"gmail_quote" style=
=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding=
-left:1ex"><div dir=3D"ltr">4) Yes, it is minimal. The goal was never to sp=
ecify a fully usable thread pool - only that some minimal structure be prov=
ided such that minimal executors can be defined. Trying to specify a perfec=
t thread pool, assuming one to exist, would delay the executors specificati=
on for no gain. =C2=A0</div></blockquote><div><br></div><div>If it is a min=
imal one, I think it should not support "wait" or "stop"=
; operations, and should be MoveConstructible. More importantly, the destru=
ctor should be non-blocking.</div><div><br></div></div></blockquote><div><b=
r></div><div>I don't think that's possible.</div><div>There is a ne=
ed, in my experience, for an explicit synchronization point with all the un=
derlying threads to be able to make sense of the program.</div></div></div>=
</blockquote><div><br></div></span><div>I think that is what the users shou=
ld concern about, not us. Users could use latches, futures or some other st=
ructural support utilities proposed in another paper of mine (P0642) to con=
trol the flow.</div><span><div>=C2=A0</div></span></div></blockquote><div><=
br></div><div>How do you provide the user any control if they don't ajv=
e access to what is controlling the underlying thread?</div><div>Threads ar=
e resources, they have to be managed explicitely in some ways. Hiding them =
from the user is good but they still need to know what some will be created=
and where their lifetime will end.</div><div>Also, the user is usually con=
cerned with the task, not the thread.</div></div></div></blockquote><div><b=
r></div></span><div>As I replied to=C2=A0Mysen, I think it is not necessary=
both for users and library implementators.</div><span class=3D""><div><br>=
</div></span></div></blockquote><div><br></div><div>That do not match my ex=
perience, but maybe there is need for both.</div><div>=C2=A0</div><blockquo=
te class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc so=
lid;padding-left:1ex"><div dir=3D"ltr"><span class=3D""><div></div><blockqu=
ote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1=
px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"=
><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border=
-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><=
blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-l=
eft:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div clas=
s=3D"gmail_quote"><div>For example in your following example, the tasks pus=
hed in that thread pool can survive the lifetime of the thread pool. That m=
akes=C2=A0</div><div>reasoning almost impossible. To put it another way: it=
goes against RAII principles and definitely is not the good way to go.</di=
v></div></div></blockquote><div><br></div></span><div>I do not understand h=
ow you come to the conclusion that "it goes against RAII principles&qu=
ot;. If my understanding is right, RAII is about "initializing the res=
ource when it is acquired", and I did not find my code against this pr=
inciple. Is there anything I missed?</div></div></blockquote><div><br></div=
><div>RAII imply, more importantly, that the resources acquired are guarant=
eed to be released in a deterministic way, when the destructor is called.</=
div><div>It's important to make sure that after you destroying=C2=A0 th=
e thread pool , there should be no thread from that thread pool still alive=
, otherwise it makes reasoning very hard.</div></div></div></blockquote><bl=
ockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-l=
eft:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_q=
uote"><div>Forcing either the user to call a function to end al the threads=
(maybe returning a future, acting like a barrier), that must be called oth=
erwise the thread pool destructor will call terminate</div><div>OR guarante=
e that we will not get out from the thread-pool destructor until all the ma=
naged threads are joined,</div><div>are important variations of the guarant=
ee needed to keep reasonning with the resources possible.</div></div></div>=
</blockquote><div><br></div></span><div>I think if the thread pool is corre=
ctly used, the task queue shall always be empty when destroying the thread =
pool, and the resources (mutex, queue, etc.) would be released shortly afte=
r the destruction.</div><span class=3D""><div><br></div></span></div></bloc=
kquote><div><br></div><div>We agree on this, though by nature we can't =
garantee that without some way to provide a synchronization mechanism to th=
e user, sync of the end of all the resources/threads.</div><div>As we can&#=
39;t return a future from the destructor, there is not much we can do to pr=
ovide this guarantee.</div><div>=C2=A0</div><blockquote class=3D"gmail_quot=
e" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">=
<div dir=3D"ltr"><span class=3D""><div></div><blockquote class=3D"gmail_quo=
te" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-=
left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"=
gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(20=
4,204,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>Actually, thi=
s implementation could be abused if one does not have the ability to write =
concurrent programs correctly. This=C2=A0phenomenon is common in the whole =
C++ programming language, not only at this point.</div><span><div><br></div=
></span></div></blockquote><div><br></div><div>I don't think it have an=
ything to do with the other code. You explicitely make threads live longer =
than the thread pool without providing life ownership to the user.</div><di=
v>To me, it's some kind of thread leak. It might not hurt, but it will =
confuse a lot. (I've been there) In particular when trying to reason ab=
out the user code. You are not sure when is finished what</div><div>just by=
reading the code.</div></div></div></blockquote><div><br></div></span><div=
>I think this is a part of the difficulty of concurrent programming. Howeve=
r, the difficulty will not be reduced effectively by joining the threads, a=
nd will definitely reduce performance.</div><span class=3D""><div><br></div=
></span></div></blockquote><div><br></div><div>It is indeed. What I mean is=
that if all your construct have clear resource lifetime semantics, it'=
s actually far easier (without any need for impact performance) to reason a=
bout concurrent code.</div><div>This is what I've been experimenting wi=
th with great results.</div><div><br></div><div>=C2=A0</div><blockquote cla=
ss=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;pa=
dding-left:1ex"><div dir=3D"ltr"><span class=3D""><blockquote class=3D"gmai=
l_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;pad=
ding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>So basicall=
y, there are other thread pool/execution context proposals on the work, app=
arently.</div><div>I just don't know who is working on them. Maybe you =
can provide some yourself, it can be separate proposals.</div></div></div><=
/blockquote><div><br></div></span><div>Actually, I have implemented various=
of thread pools on different platforms with different mechanisms (as I men=
tioned, bounded queue, keep-alive duration, threads with attributes, work-s=
tealing, timing, merging, etc.), but I have not finished related=C2=A0techn=
ical specifications that reasonable and=C2=A0motivating enough yet.</div><s=
pan class=3D""><div><br></div></span></div></blockquote><div><br></div><div=
>You probably have enough background to make some proposals in this directi=
on. Maybe contact Micheal Wong to see if you can help with the other potent=
ial thread-pool and executors proposals.</div><div>=C2=A0</div><blockquote =
class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid=
;padding-left:1ex"><div dir=3D"ltr"><span class=3D""><div></div><blockquote=
class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px =
#ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><b=
lockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-le=
ft:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div>I wou=
ld appreciate it if you could provide a better implementation and benchmark=
..</div></div></blockquote><div><br></div><div>Well, all performant thread p=
ools I know of use "work-stealing" algorithms which imply having =
1 queue per thread</div><div>and the algorithm re-equilibrate the workload =
depending on some parametters. I understand it is not trivial</div><div>and=
didn't attempt to implement one (in critical cases I would do like you=
, a "naive but working" one).</div><div><br></div><div>For exampl=
e of such implementations, look at:</div><div>=C2=A0- Intel Threading Build=
ing Blocks;</div><div>=C2=A0- HPX;</div><div>=C2=A0- maybe Boost.Thread exp=
erimental thread pool do work stealing, I'm not sure, I didn't chec=
k.</div></div></div></blockquote><div><br></div></span><div>As far as I am =
concered, "work-stealing" strategy is useful almost only when the=
re are a lot of `wait` in our original code, and we want to reconstruct the=
m within a short period to increase performance. However, "work-steali=
ng" strategy=C2=A0is usually inefficient in well-design algorithms.</d=
iv><span class=3D""><div><br></div></span></div></blockquote><div><br></div=
><div>My understanding is totally different: work-stealing does the workloa=
d balance for threads in more efficient way than simpler algorithms for man=
aging task queues. It have nothing to do with waiting, but it does have to =
do with the</div><div>unpredictable nature of execution time of varied kind=
s of work (so it's helful even when task implementors persist with wait=
ing).</div><div>It works well in the case we don't know what tasks will=
be executed and when. This is why most general-purpose thread-pools are us=
ing some variant of work-stealing (as showed in the talk video).</div><div>=
<br></div><div>So if you are in a specialized case where tasks are very spe=
cific (like, all the same with different parametters), then it's indeed=
less optimal than a specific executor/thread-pool etc.</div><div>=C2=A0</d=
iv><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left=
:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span class=3D""><div></=
div><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;b=
order-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"=
gmail_quote"><div>I also recommend checking this talk from Sean Parent clar=
ifying the issue with the code you provided:=C2=A0<a href=3D"https://www.yo=
utube.com/watch?v=3DzULU6Hhp42w" rel=3D"nofollow" target=3D"_blank">https:/=
/www.youtube.<wbr>com/watch?v=3DzULU6Hhp42w</a></div><div>Also "C++ Co=
ncurrency In Action" book clarify the details of all that, and if you =
didn't read it and the subject</div><div>is interesting to you, it woul=
d be very interesting for you.</div></div></div></blockquote><div><br></div=
></span><div>Thank you for the=C2=A0recommendations.=C2=A0I will check it o=
ut.</div></div></blockquote><blockquote class=3D"gmail_quote" style=3D"marg=
in:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><span class=3D""=
>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/484c=
23da-2cc1-44ca-<wbr>822b-19d512d71309%40isocpp.org</a><wbr>.<br>
</blockquote></div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOU91OODTLK7KWcrBQxCE62LWkfitw%3Dp6r=
im%3DQRHBJrNwqj7Mg%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter"=
>https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OODTLK7=
KWcrBQxCE62LWkfitw%3Dp6rim%3DQRHBJrNwqj7Mg%40mail.gmail.com</a>.<br />
--000000000000c4a7ff0568f3f7e1--
.
Author: Lee Howes <xrikcus@gmail.com>
Date: Tue, 3 Apr 2018 13:50:07 -0700
Raw View
--0000000000000e87c20568f7da5d
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
A simple example of where properties do not change the concrete interface
(and would not be detectable without the trait) is in the proposal as the
blocking property:
The `blocking_t` property describes what guarantees executors provide
about the blocking behavior of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|------------------------|--------------|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an
executor's execution function may block pending completion of one or
more of the execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an
executor's execution function shall block until completion of all
execution agents created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an
executor's execution function shall not block pending completion of
the execution agents created by that execution function. |
This is a very important property because it is vitally important that I
can push a continuation into an executor such a guarantee that it will not
block the caller. An inline executor would not satisfy that property,
because it would block until the function is complete. An executor with a
logically infinite queue can guarantee that it is non-blocking, and should
say so.
The execute function looks the same but I can use that trait as a filter on
what executor my library accepts.
On 3 April 2018 at 09:11, Klaim - Jo=C3=ABl Lamotte <mjklaim@gmail.com> wro=
te:
>
>
> On 3 April 2018 at 11:58, Mingxin Wang <wmx16835vv@163.com> wrote:
>
>>
>>
>>>>> ... and we can also define other facades based on them if necessary:
>>>>
>>>> facade MyExecutor : OneWayExecutor, TwoWayExecutor {
>>>> void wait_for_all_tasks_to_be_done_or_something();
>>>> void reset_worker_count(std::size_t new_count);
>>>> static std::string some_type_specific_description();
>>>> };
>>>>
>>>>
>>> This part is not what is needed. We need to be able to compose with
>>> several requirements, not have to create another one.
>>>
>>
>> Do you mean conjunction? In the example above, `MyExecutor` is a
>> conjunction of `OneWayExecutor` and `TwoWayExecutor`.
>>
>>
> I see, I misread assuming MyExecutor was a conjonction of both
> requirements instead of an actual executor.
>
>
>> Providing there is a type `my_awesome_executor` meets the requirements
>>>> defined by the facade, the following code shows its basic usage:
>>>>
>>>> const my_awesome_executor ex;
>>>> static_proxy<MyExecutor&> p0(ex); // Error; Because `const` value is
>>>> not convertible to `non-const` reference;
>>>> static_proxy<const MyExecutor&> p1(ex); // OK;
>>>> static_proxy<MyExecutor> p2(ex); // OK; The copy-constructor is calle=
d;
>>>> static_proxy<MyExecutor> p3(std::move(ex)); // OK; The
>>>> move-constructor is called;
>>>> std::cout << p3.type() << std::endl; // OK; Print the result of
>>>> `typeid(my_awesome_executor)`;
>>>> static_proxy<const OneWayExecutor&> p4(p2); // OK; `non-const` value
>>>> is convertible to `const` reference;
>>>> static_proxy<volatile MyExecutor> p5(std::move(p3)); // OK;
>>>> `non-volatile` value is convertible to `volatile` value;
>>>> std::cout << p3.has_value() << std::endl; // OK; Print `false`,
>>>> because the value has been moved to `p5`;
>>>> p4.execute([] { std::cout << "Life is so cool!" << std::endl; }); //
>>>> OK;
>>>> p5.execute([] { std::cout << "Although bad things happen sometimes..."
>>>> << std::endl; }); // Error; The `execute` function is not `volatile`;
>>>>
>>>>
>>> Note that the current executor proposal to not necessarilly associate a
>>> requirement to a specific interface. It would be possible
>>> to have a requirement not change the interface (but change the semantic=
).
>>>
>>
>> I do not understand what you mean by this paragraph. Could you please
>> clarify it?
>>
>
> This is my understanding of the current executor proposal, so maybe I'm
> wrong but let's say that I want to introduce a new type of requirement:
>
> struct MaybeOnline {};
>
> I do not necessarilly have a specific interface that an executor must
> provide. It might just expose a tag type to be discernable.
> It might not introduce a member function, to be clear.
>
> Just wanted that to be clear. The prerequisite types does not seem to be
> interfaces themselves, they seem to be tags implying interfaces.
>
>
>>
>> 4) Yes, it is minimal. The goal was never to specify a fully usable
>>>>>>> thread pool - only that some minimal structure be provided such tha=
t
>>>>>>> minimal executors can be defined. Trying to specify a perfect threa=
d pool,
>>>>>>> assuming one to exist, would delay the executors specification for =
no gain.
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> If it is a minimal one, I think it should not support "wait" or
>>>>>> "stop" operations, and should be MoveConstructible. More importantly=
, the
>>>>>> destructor should be non-blocking.
>>>>>>
>>>>>>
>>>>> I don't think that's possible.
>>>>> There is a need, in my experience, for an explicit synchronization
>>>>> point with all the underlying threads to be able to make sense of the
>>>>> program.
>>>>>
>>>>
>>>> I think that is what the users should concern about, not us. Users
>>>> could use latches, futures or some other structural support utilities
>>>> proposed in another paper of mine (P0642) to control the flow.
>>>>
>>>>
>>>
>>> How do you provide the user any control if they don't ajve access to
>>> what is controlling the underlying thread?
>>> Threads are resources, they have to be managed explicitely in some ways=
..
>>> Hiding them from the user is good but they still need to know what some
>>> will be created and where their lifetime will end.
>>> Also, the user is usually concerned with the task, not the thread.
>>>
>>
>> As I replied to Mysen, I think it is not necessary both for users and
>> library implementators.
>>
>>
> That do not match my experience, but maybe there is need for both.
>
>
>> For example in your following example, the tasks pushed in that thread
>>>>> pool can survive the lifetime of the thread pool. That makes
>>>>> reasoning almost impossible. To put it another way: it goes against
>>>>> RAII principles and definitely is not the good way to go.
>>>>>
>>>>
>>>> I do not understand how you come to the conclusion that "it goes
>>>> against RAII principles". If my understanding is right, RAII is about
>>>> "initializing the resource when it is acquired", and I did not find my=
code
>>>> against this principle. Is there anything I missed?
>>>>
>>>
>>> RAII imply, more importantly, that the resources acquired are guarantee=
d
>>> to be released in a deterministic way, when the destructor is called.
>>> It's important to make sure that after you destroying the thread pool =
,
>>> there should be no thread from that thread pool still alive, otherwise =
it
>>> makes reasoning very hard.
>>>
>> Forcing either the user to call a function to end al the threads (maybe
>>> returning a future, acting like a barrier), that must be called otherwi=
se
>>> the thread pool destructor will call terminate
>>> OR guarantee that we will not get out from the thread-pool destructor
>>> until all the managed threads are joined,
>>> are important variations of the guarantee needed to keep reasonning wit=
h
>>> the resources possible.
>>>
>>
>> I think if the thread pool is correctly used, the task queue shall alway=
s
>> be empty when destroying the thread pool, and the resources (mutex, queu=
e,
>> etc.) would be released shortly after the destruction.
>>
>>
> We agree on this, though by nature we can't garantee that without some wa=
y
> to provide a synchronization mechanism to the user, sync of the end of al=
l
> the resources/threads.
> As we can't return a future from the destructor, there is not much we can
> do to provide this guarantee.
>
>
>> Actually, this implementation could be abused if one does not have the
>>>> ability to write concurrent programs correctly. This phenomenon is com=
mon
>>>> in the whole C++ programming language, not only at this point.
>>>>
>>>>
>>> I don't think it have anything to do with the other code. You
>>> explicitely make threads live longer than the thread pool without provi=
ding
>>> life ownership to the user.
>>> To me, it's some kind of thread leak. It might not hurt, but it will
>>> confuse a lot. (I've been there) In particular when trying to reason ab=
out
>>> the user code. You are not sure when is finished what
>>> just by reading the code.
>>>
>>
>> I think this is a part of the difficulty of concurrent programming.
>> However, the difficulty will not be reduced effectively by joining the
>> threads, and will definitely reduce performance.
>>
>>
> It is indeed. What I mean is that if all your construct have clear
> resource lifetime semantics, it's actually far easier (without any need f=
or
> impact performance) to reason about concurrent code.
> This is what I've been experimenting with with great results.
>
>
>
>> So basically, there are other thread pool/execution context proposals on
>>> the work, apparently.
>>> I just don't know who is working on them. Maybe you can provide some
>>> yourself, it can be separate proposals.
>>>
>>
>> Actually, I have implemented various of thread pools on different
>> platforms with different mechanisms (as I mentioned, bounded queue,
>> keep-alive duration, threads with attributes, work-stealing, timing,
>> merging, etc.), but I have not finished related technical specifications
>> that reasonable and motivating enough yet.
>>
>>
> You probably have enough background to make some proposals in this
> direction. Maybe contact Micheal Wong to see if you can help with the oth=
er
> potential thread-pool and executors proposals.
>
>
>> I would appreciate it if you could provide a better implementation and
>>>> benchmark.
>>>>
>>>
>>> Well, all performant thread pools I know of use "work-stealing"
>>> algorithms which imply having 1 queue per thread
>>> and the algorithm re-equilibrate the workload depending on some
>>> parametters. I understand it is not trivial
>>> and didn't attempt to implement one (in critical cases I would do like
>>> you, a "naive but working" one).
>>>
>>> For example of such implementations, look at:
>>> - Intel Threading Building Blocks;
>>> - HPX;
>>> - maybe Boost.Thread experimental thread pool do work stealing, I'm no=
t
>>> sure, I didn't check.
>>>
>>
>> As far as I am concered, "work-stealing" strategy is useful almost only
>> when there are a lot of `wait` in our original code, and we want to
>> reconstruct them within a short period to increase performance. However,
>> "work-stealing" strategy is usually inefficient in well-design algorithm=
s.
>>
>>
> My understanding is totally different: work-stealing does the workload
> balance for threads in more efficient way than simpler algorithms for
> managing task queues. It have nothing to do with waiting, but it does hav=
e
> to do with the
> unpredictable nature of execution time of varied kinds of work (so it's
> helful even when task implementors persist with waiting).
> It works well in the case we don't know what tasks will be executed and
> when. This is why most general-purpose thread-pools are using some varian=
t
> of work-stealing (as showed in the talk video).
>
> So if you are in a specialized case where tasks are very specific (like,
> all the same with different parametters), then it's indeed less optimal
> than a specific executor/thread-pool etc.
>
>
>> I also recommend checking this talk from Sean Parent clarifying the issu=
e
>>> with the code you provided: https://www.youtube.com/watch?v=3DzULU6Hhp4=
2w
>>> Also "C++ Concurrency In Action" book clarify the details of all that,
>>> and if you didn't read it and the subject
>>> is interesting to you, it would be very interesting for you.
>>>
>>
>> Thank you for the recommendations. I will check it out.
>>
> --
>> You received this message because you are subscribed to the Google Group=
s
>> "ISO C++ Standard - Future Proposals" group.
>> To unsubscribe from this group and stop receiving emails from it, send a=
n
>> email to std-proposals+unsubscribe@isocpp.org.
>> To post to this group, send email to std-proposals@isocpp.org.
>> To view this discussion on the web visit https://groups.google.com/a/is
>> ocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-
>> 19d512d71309%40isocpp.org
>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/484c23da-2=
cc1-44ca-822b-19d512d71309%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoo=
ter>
>> .
>>
>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/CAOU91OODTLK7KWcrBQxCE62LWkfit
> w%3Dp6rim%3DQRHBJrNwqj7Mg%40mail.gmail.com
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OODTL=
K7KWcrBQxCE62LWkfitw%3Dp6rim%3DQRHBJrNwqj7Mg%40mail.gmail.com?utm_medium=3D=
email&utm_source=3Dfooter>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAJH_FNUxBefAn5teosFuCsCi_gUxSPmaCqLd0uOS2ETtC2W=
9JA%40mail.gmail.com.
--0000000000000e87c20568f7da5d
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">A simple example of where properties do not change the con=
crete interface (and would not be detectable without the trait) is in the p=
roposal as the blocking property:<div><pre style=3D"color:rgb(0,0,0);font-s=
tyle:normal;font-variant-ligatures:normal;font-variant-caps:normal;font-wei=
ght:400;letter-spacing:normal;text-align:start;text-indent:0px;text-transfo=
rm:none;word-spacing:0px;text-decoration-style:initial;text-decoration-colo=
r:initial;word-wrap:break-word;white-space:pre-wrap">The `blocking_t` prope=
rty describes what guarantees executors provide about the blocking behavior=
of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|------------------------|--------------|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor=
's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an executor'=
;s execution function shall block until completion of all execution agents =
created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |</pre></div><div><br></div><div>Th=
is is a very important property because it is vitally important that I can =
push a continuation into an executor such a guarantee that it will not bloc=
k the caller. An inline executor would not satisfy that property, because i=
t would block until the function is complete. An executor with a logically =
infinite queue can guarantee that it is non-blocking, and should say so.</d=
iv><div><br></div><div>The execute function looks the same but I can use th=
at trait as a filter on what executor my library accepts.</div></div><div c=
lass=3D"gmail_extra"><br><div class=3D"gmail_quote">On 3 April 2018 at 09:1=
1, Klaim - Jo=C3=ABl Lamotte <span dir=3D"ltr"><<a href=3D"mailto:mjklai=
m@gmail.com" target=3D"_blank">mjklaim@gmail.com</a>></span> wrote:<br><=
blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px=
#ccc solid;padding-left:1ex"><div dir=3D"ltr"><br><div class=3D"gmail_extr=
a"><br><div class=3D"gmail_quote"><span class=3D"">On 3 April 2018 at 11:58=
, Mingxin Wang <span dir=3D"ltr"><<a href=3D"mailto:wmx16835vv@163.com" =
target=3D"_blank">wmx16835vv@163.com</a>></span> wrote:<br><blockquote c=
lass=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;=
padding-left:1ex"><div dir=3D"ltr"><span><div><br></div><blockquote class=
=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc s=
olid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockqu=
ote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px=
solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><blockquot=
e class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px s=
olid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmai=
l_quote"><br></div></div></blockquote></span></div></blockquote><blockquote=
class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px so=
lid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div>... and we can=
also define other facades based on them if necessary:</div><div><br></div>=
<div><div style=3D"border-width:1px;border-style:solid;border-color:rgb(187=
,187,187);background-color:rgb(250,250,250);word-wrap:break-word"><code><di=
v><div><div>facade MyExecutor : OneWayExecutor, TwoWayExecutor {</div><div>=
=C2=A0 void wait_for_all_tasks_to_be_done_<wbr>or_something();</div><div>=
=C2=A0 void reset_worker_count(std::size_t new_count);</div><div>=C2=A0 sta=
tic std::string some_type_specific_description<wbr>();</div><div>};</div></=
div></div></code></div><br></div></div></blockquote><div><br></div><div>Thi=
s part is not what is needed. We need to be able to compose with several re=
quirements, not have to create another one.</div></div></div></blockquote><=
div><br></div></span><div>Do you mean=C2=A0conjunction? In the example abov=
e, `MyExecutor` is a conjunction of `OneWayExecutor` and `TwoWayExecutor`.<=
/div><span><div><br></div></span></div></blockquote><div><br></div></span><=
div>I see, I misread assuming MyExecutor was a conjonction of both requirem=
ents instead of an actual executor.</div><span class=3D""><div>=C2=A0</div>=
<blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1p=
x #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span><div></div><blockquot=
e class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px=
#ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><=
blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-l=
eft:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div>Prov=
iding there is a type `my_awesome_executor` meets the requirements defined =
by the facade, the following code shows its basic usage:</div><div><br></di=
v><div><div style=3D"background-color:rgb(250,250,250);border-color:rgb(187=
,187,187);border-style:solid;border-width:1px;word-wrap:break-word"><code><=
div><div>const my_awesome_executor ex;</div><div>static_proxy<MyExecutor=
&> p0(ex); =C2=A0// Error; Because `const` value is not convertible =
to `non-const` reference;</div><div>static_proxy<const MyExecutor&&g=
t; p1(ex); =C2=A0// OK;</div><div>static_proxy<MyExecutor> p2(ex); =
=C2=A0// OK; The copy-constructor is called;</div><div>static_proxy<MyEx=
ecutor> p3(std::move(ex)); =C2=A0// OK; The move-constructor is called;<=
/div><div>std::cout << p3.type() << std::endl; =C2=A0// OK; Pri=
nt the result of `typeid(my_awesome_executor)`;</div><div>static_proxy<c=
onst OneWayExecutor&> p4(p2); =C2=A0// OK; `non-const` value is conv=
ertible to `const` reference;</div><div>static_proxy<volatile MyExecutor=
> p5(std::move(p3)); =C2=A0// OK; `non-volatile` value is convertible to=
`volatile` value;</div><div>std::cout << p3.has_value() << std=
::endl; =C2=A0// OK; Print `false`, because the value has been moved to `p5=
`;</div><div>p4.execute([] { std::cout << "Life is so cool!"=
; << std::endl; }); =C2=A0// OK;</div><div>p5.execute([] { std::cout =
<< "Although bad things happen sometimes..." << std::=
endl; }); =C2=A0// Error; The `execute` function is not `volatile`;</div></=
div></code></div></div><span><div><br></div></span></div></blockquote><div>=
<br></div><div>Note that the current executor proposal to not necessarilly =
associate a requirement to a specific interface. It would be possible</div>=
<div>to have a requirement not change the interface (but change the semanti=
c).</div></div></div></blockquote><div><br></div></span><div>I do not under=
stand what you mean by this=C2=A0paragraph. Could you please clarify it?</d=
iv></div></blockquote><div><br></div></span><div>This is my understanding o=
f the current executor proposal, so maybe I'm wrong but let's say t=
hat I want to introduce a new type of requirement:</div><div><br></div><div=
>struct MaybeOnline {};=C2=A0</div><div><br></div><div>I do not necessarill=
y have a specific interface that an executor must provide. It might just ex=
pose a tag type to be discernable.</div><div>It might not introduce a membe=
r function, to be clear.</div><div><br></div><div>Just wanted that to be cl=
ear. The prerequisite types does not seem to be interfaces themselves, they=
seem to be tags implying interfaces.</div><span class=3D""><div>=C2=A0</di=
v><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:=
1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span><div><br></div><blo=
ckquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-le=
ft:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_qu=
ote"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;bo=
rder-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><sp=
an><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;bord=
er-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div =
class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"margin:0px=
0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><di=
v dir=3D"ltr"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px=
0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D=
"ltr">4) Yes, it is minimal. The goal was never to specify a fully usable t=
hread pool - only that some minimal structure be provided such that minimal=
executors can be defined. Trying to specify a perfect thread pool, assumin=
g one to exist, would delay the executors specification for no gain. =C2=A0=
</div></blockquote><div><br></div><div>If it is a minimal one, I think it s=
hould not support "wait" or "stop" operations, and shou=
ld be MoveConstructible. More importantly, the destructor should be non-blo=
cking.</div><div><br></div></div></blockquote><div><br></div><div>I don'=
;t think that's possible.</div><div>There is a need, in my experience, =
for an explicit synchronization point with all the underlying threads to be=
able to make sense of the program.</div></div></div></blockquote><div><br>=
</div></span><div>I think that is what the users should concern about, not =
us. Users could use latches, futures or some other structural support utili=
ties proposed in another paper of mine (P0642) to control the flow.</div><s=
pan><div>=C2=A0</div></span></div></blockquote><div><br></div><div>How do y=
ou provide the user any control if they don't ajve access to what is co=
ntrolling the underlying thread?</div><div>Threads are resources, they have=
to be managed explicitely in some ways. Hiding them from the user is good =
but they still need to know what some will be created and where their lifet=
ime will end.</div><div>Also, the user is usually concerned with the task, =
not the thread.</div></div></div></blockquote><div><br></div></span><div>As=
I replied to=C2=A0Mysen, I think it is not necessary both for users and li=
brary implementators.</div><span><div><br></div></span></div></blockquote><=
div><br></div></span><div>That do not match my experience, but maybe there =
is need for both.</div><span class=3D""><div>=C2=A0</div><blockquote class=
=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padd=
ing-left:1ex"><div dir=3D"ltr"><span><div></div><blockquote class=3D"gmail_=
quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;paddi=
ng-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=
=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rg=
b(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><blockquote class=
=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rg=
b(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote=
"><div>For example in your following example, the tasks pushed in that thre=
ad pool can survive the lifetime of the thread pool. That makes=C2=A0</div>=
<div>reasoning almost impossible. To put it another way: it goes against RA=
II principles and definitely is not the good way to go.</div></div></div></=
blockquote><div><br></div></span><div>I do not understand how you come to t=
he conclusion that "it goes against RAII principles". If my under=
standing is right, RAII is about "initializing the resource when it is=
acquired", and I did not find my code against this principle. Is ther=
e anything I missed?</div></div></blockquote><div><br></div><div>RAII imply=
, more importantly, that the resources acquired are guaranteed to be releas=
ed in a deterministic way, when the destructor is called.</div><div>It'=
s important to make sure that after you destroying=C2=A0 the thread pool , =
there should be no thread from that thread pool still alive, otherwise it m=
akes reasoning very hard.</div></div></div></blockquote><blockquote class=
=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc s=
olid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>For=
cing either the user to call a function to end al the threads (maybe return=
ing a future, acting like a barrier), that must be called otherwise the thr=
ead pool destructor will call terminate</div><div>OR guarantee that we will=
not get out from the thread-pool destructor until all the managed threads =
are joined,</div><div>are important variations of the guarantee needed to k=
eep reasonning with the resources possible.</div></div></div></blockquote><=
div><br></div></span><div>I think if the thread pool is correctly used, the=
task queue shall always be empty when destroying the thread pool, and the =
resources (mutex, queue, etc.) would be released shortly after the destruct=
ion.</div><span><div><br></div></span></div></blockquote><div><br></div></s=
pan><div>We agree on this, though by nature we can't garantee that with=
out some way to provide a synchronization mechanism to the user, sync of th=
e end of all the resources/threads.</div><div>As we can't return a futu=
re from the destructor, there is not much we can do to provide this guarant=
ee.</div><span class=3D""><div>=C2=A0</div><blockquote class=3D"gmail_quote=
" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><=
div dir=3D"ltr"><span><div></div><blockquote class=3D"gmail_quote" style=3D=
"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><d=
iv dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote"=
style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);p=
adding-left:1ex"><div dir=3D"ltr"><div></div><div>Actually, this implementa=
tion could be abused if one does not have the ability to write concurrent p=
rograms correctly. This=C2=A0phenomenon is common in the whole C++ programm=
ing language, not only at this point.</div><span><div><br></div></span></di=
v></blockquote><div><br></div><div>I don't think it have anything to do=
with the other code. You explicitely make threads live longer than the thr=
ead pool without providing life ownership to the user.</div><div>To me, it&=
#39;s some kind of thread leak. It might not hurt, but it will confuse a lo=
t. (I've been there) In particular when trying to reason about the user=
code. You are not sure when is finished what</div><div>just by reading the=
code.</div></div></div></blockquote><div><br></div></span><div>I think thi=
s is a part of the difficulty of concurrent programming. However, the diffi=
culty will not be reduced effectively by joining the threads, and will defi=
nitely reduce performance.</div><span><div><br></div></span></div></blockqu=
ote><div><br></div></span><div>It is indeed. What I mean is that if all you=
r construct have clear resource lifetime semantics, it's actually far e=
asier (without any need for impact performance) to reason about concurrent =
code.</div><div>This is what I've been experimenting with with great re=
sults.</div><span class=3D""><div><br></div><div>=C2=A0</div><blockquote cl=
ass=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;p=
adding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" s=
tyle=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:=
1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>So basically, there a=
re other thread pool/execution context proposals on the work, apparently.</=
div><div>I just don't know who is working on them. Maybe you can provid=
e some yourself, it can be separate proposals.</div></div></div></blockquot=
e><div><br></div></span><div>Actually, I have implemented various of thread=
pools on different platforms with different mechanisms (as I mentioned, bo=
unded queue, keep-alive duration, threads with attributes, work-stealing, t=
iming, merging, etc.), but I have not finished related=C2=A0technical speci=
fications that reasonable and=C2=A0motivating enough yet.</div><span><div><=
br></div></span></div></blockquote><div><br></div></span><div>You probably =
have enough background to make some proposals in this direction. Maybe cont=
act Micheal Wong to see if you can help with the other potential thread-poo=
l and executors proposals.</div><span class=3D""><div>=C2=A0</div><blockquo=
te class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc so=
lid;padding-left:1ex"><div dir=3D"ltr"><span><div></div><blockquote class=
=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc s=
olid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockqu=
ote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px=
solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div>I would app=
reciate it if you could provide a better implementation and benchmark.</div=
></div></blockquote><div><br></div><div>Well, all performant thread pools I=
know of use "work-stealing" algorithms which imply having 1 queu=
e per thread</div><div>and the algorithm re-equilibrate the workload depend=
ing on some parametters. I understand it is not trivial</div><div>and didn&=
#39;t attempt to implement one (in critical cases I would do like you, a &q=
uot;naive but working" one).</div><div><br></div><div>For example of s=
uch implementations, look at:</div><div>=C2=A0- Intel Threading Building Bl=
ocks;</div><div>=C2=A0- HPX;</div><div>=C2=A0- maybe Boost.Thread experimen=
tal thread pool do work stealing, I'm not sure, I didn't check.</di=
v></div></div></blockquote><div><br></div></span><div>As far as I am concer=
ed, "work-stealing" strategy is useful almost only when there are=
a lot of `wait` in our original code, and we want to reconstruct them with=
in a short period to increase performance. However, "work-stealing&quo=
t; strategy=C2=A0is usually inefficient in well-design algorithms.</div><sp=
an><div><br></div></span></div></blockquote><div><br></div></span><div>My u=
nderstanding is totally different: work-stealing does the workload balance =
for threads in more efficient way than simpler algorithms for managing task=
queues. It have nothing to do with waiting, but it does have to do with th=
e</div><div>unpredictable nature of execution time of varied kinds of work =
(so it's helful even when task implementors persist with waiting).</div=
><div>It works well in the case we don't know what tasks will be execut=
ed and when. This is why most general-purpose thread-pools are using some v=
ariant of work-stealing (as showed in the talk video).</div><div><br></div>=
<div>So if you are in a specialized case where tasks are very specific (lik=
e, all the same with different parametters), then it's indeed less opti=
mal than a specific executor/thread-pool etc.</div><span class=3D""><div>=
=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;bo=
rder-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><span><div></di=
v><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;bor=
der-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gm=
ail_quote"><div>I also recommend checking this talk from Sean Parent clarif=
ying the issue with the code you provided:=C2=A0<a href=3D"https://www.yout=
ube.com/watch?v=3DzULU6Hhp42w" rel=3D"nofollow" target=3D"_blank">https://w=
ww.youtube.<wbr>com/watch?v=3DzULU6Hhp42w</a></div><div>Also "C++ Conc=
urrency In Action" book clarify the details of all that, and if you di=
dn't read it and the subject</div><div>is interesting to you, it would =
be very interesting for you.</div></div></div></blockquote><div><br></div><=
/span><div>Thank you for the=C2=A0recommendations.=C2=A0I will check it out=
..</div></div></blockquote><blockquote class=3D"gmail_quote" style=3D"margin=
:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><span>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isoc<wbr>pp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/484c23da-2cc1-44ca-822b-19d512d71309%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/is<wbr>ocpp.org/d/msgid/std-proposals<wbr>/484c=
23da-2cc1-44ca-822b-<wbr>19d512d71309%40isocpp.org</a>.<br>
</blockquote></span></div><br></div></div><span class=3D"">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOU91OODTLK7KWcrBQxCE62LWkfitw%3Dp6r=
im%3DQRHBJrNwqj7Mg%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfoo=
ter" target=3D"_blank">https://groups.google.com/a/<wbr>isocpp.org/d/msgid/=
std-<wbr>proposals/<wbr>CAOU91OODTLK7KWcrBQxCE62LWkfit<wbr>w%3Dp6rim%3DQRHB=
JrNwqj7Mg%<wbr>40mail.gmail.com</a>.<br>
</blockquote></div><br></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAJH_FNUxBefAn5teosFuCsCi_gUxSPmaCqLd=
0uOS2ETtC2W9JA%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">htt=
ps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNUxBefAn5te=
osFuCsCi_gUxSPmaCqLd0uOS2ETtC2W9JA%40mail.gmail.com</a>.<br />
--0000000000000e87c20568f7da5d--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Wed, 4 Apr 2018 10:17:27 -0700 (PDT)
Raw View
------=_Part_27527_1687849433.1522862247483
Content-Type: multipart/alternative;
boundary="----=_Part_27528_1948064371.1522862247483"
------=_Part_27528_1948064371.1522862247483
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Wednesday, April 4, 2018 at 12:12:09 AM UTC+8, Klaim - Jo=C3=ABl Lamotte=
=20
wrote:
>
> On 3 April 2018 at 11:58, Mingxin Wang <wmx16...@163.com <javascript:>>=
=20
> wrote:
>
>>
>>> Note that the current executor proposal to not necessarilly associate a=
=20
>>> requirement to a specific interface. It would be possible
>>> to have a requirement not change the interface (but change the semantic=
).
>>>
>>
>> I do not understand what you mean by this paragraph. Could you please=20
>> clarify it?
>>
>
> This is my understanding of the current executor proposal, so maybe I'm=
=20
> wrong but let's say that I want to introduce a new type of requirement:
>
> struct MaybeOnline {};=20
>
> I do not necessarilly have a specific interface that an executor must=20
> provide. It might just expose a tag type to be discernable.
> It might not introduce a member function, to be clear.
>
> Just wanted that to be clear. The prerequisite types does not seem to be=
=20
> interfaces themselves, they seem to be tags implying interfaces.
>
Thank you for the clarification.
From my point of view, the "tags" and the "interfaces" are different =E2=80=
=94 the=20
"tags" defines the properties, and we are able to make decisions with them=
=20
(basically with `if-else` or `switch` statements); while the "interfaces"=
=20
defines the functionality, that could be used under specific preconditions=
=20
(basically with templates or function pointers).
By the way, I do not think names like `operator bool()` or `target_type()`=
=20
in the polymorphic executor are more reasonable than `has_value()` or=20
`type()` in `std::any` or `static_addresser` in P0957.
How do you provide the user any control if they don't ajve access to what=
=20
>>> is controlling the underlying thread?
>>> Threads are resources, they have to be managed explicitely in some ways=
..=20
>>> Hiding them from the user is good but they still need to know what some=
=20
>>> will be created and where their lifetime will end.
>>> Also, the user is usually concerned with the task, not the thread.
>>>
>>
>> As I replied to Mysen, I think it is not necessary both for users and=20
>> library implementators.
>>
>> That do not match my experience, but maybe there is need for both.
>
As an implementator, I think it may be acceptable to save the thread=20
objects in a thread pool with fixed number of worker threads. However, when=
=20
it comes to dynamic thread pools, managing the thread objects would make=20
the algorithm more complex =E2=80=94 at least, we need to store a more comp=
licated=20
data structure (e.g., `std::set`, `std::unordered_set` or some lock-free=20
ones) than `std::vector`; when threads exit automatically, their objects=20
shall also be detached. Still, there seems to be little motivation to do=20
this if one is able to write concurrent code correctly. Thus I think we do=
=20
not need both.
You probably have enough background to make some proposals in this=20
> direction. Maybe contact Micheal Wong to see if you can help with the oth=
er=20
> potential thread-pool and executors proposals.
>
Thank you for your recognition. Actually, I am a big fan of Michael Wong,=
=20
and learnt C++11 with his book.
Recently, I have been trying to remove some existing concepts (e.g., Binary=
=20
Semaphore and Execution Agent Portal) in P0642 for the next revision. Since=
=20
P0642 requires abstraction of execution, I believe its API would become=20
more ease-to-use with the support of the Executors TS.
Well, all performant thread pools I know of use "work-stealing" algorithms=
=20
>>> which imply having 1 queue per thread
>>> and the algorithm re-equilibrate the workload depending on some=20
>>> parametters. I understand it is not trivial
>>> and didn't attempt to implement one (in critical cases I would do like=
=20
>>> you, a "naive but working" one).
>>>
>>> For example of such implementations, look at:
>>> - Intel Threading Building Blocks;
>>> - HPX;
>>> - maybe Boost.Thread experimental thread pool do work stealing, I'm no=
t=20
>>> sure, I didn't check.
>>>
>>
>> As far as I am concered, "work-stealing" strategy is useful almost only=
=20
>> when there are a lot of `wait` in our original code, and we want to=20
>> reconstruct them within a short period to increase performance. However,=
=20
>> "work-stealing" strategy is usually inefficient in well-design algorithm=
s.
>>
>
> My understanding is totally different: work-stealing does the workload=20
> balance for threads in more efficient way than simpler algorithms for=20
> managing task queues.
>
What do you mean by "in a more efficient way"? Do you mean the "Half=20
Sync/Half Async" pattern? I am not quite familiar with the implementations=
=20
you mentioned, but in Java, the "Fork Join Pool" seems not have such=20
feature.
=20
> It have nothing to do with waiting, but it does have to do with the
> unpredictable nature of execution time of varied kinds of work (so it's=
=20
> helful even when task implementors persist with waiting).
> It works well in the case we don't know what tasks will be executed and=
=20
> when. This is why most general-purpose thread-pools are using some varian=
t=20
> of work-stealing (as showed in the talk video).
>
As far as I am concerned, work-stealing is about "executing irrelevant work=
=20
while waiting". In the "Fork Join Pool" in Java, a task should always wait=
=20
for a forked task to be done with a specific API to work. The=20
implementation registers the waiting thread to a internal data structure,=
=20
and assigns tasks if available, resulting in possible delay for the waiting=
=20
operation to unblock. All these works produce overhead.
However, if we use `async_concurrent_invoke` proposed in P0642, there won't=
=20
be any blocking at all, and there will be little necessity to use=20
"work-stealing" strategy. As asynchronous programming will make it more=20
complex to manage resources, especially execution agents, so a=20
"synchronous" version is also provided as `sync_concurrent_invoke`, where=
=20
one could specify custom blocking algorithm, including the "work-stealing"=
=20
if necessary. There is a more detailed analysis in P0642.
Honestly, I have not read the code of the facilities you mentioned, and I=
=20
am not sure whether they have different mechanism to the "Fork Join Pool"=
=20
in Java. If so, could you provide any related code or document? Thank you.
So if you are in a specialized case where tasks are very specific (like,=20
> all the same with different parametters), then it's indeed less optimal=
=20
> than a specific executor/thread-pool etc.
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/31ab339c-c7e5-4b3b-ac90-32d7440642b4%40isocpp.or=
g.
------=_Part_27528_1948064371.1522862247483
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Wednesday, April 4, 2018 at 12:12:09 AM UTC+8, Klaim - =
Jo=C3=ABl Lamotte wrote:<blockquote class=3D"gmail_quote" style=3D"margin: =
0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div d=
ir=3D"ltr"><div><div class=3D"gmail_quote">On 3 April 2018 at 11:58, Mingxi=
n Wang <span dir=3D"ltr"><<a href=3D"javascript:" target=3D"_blank" gdf-=
obfuscated-mailto=3D"ObTx7MiMBQAJ" rel=3D"nofollow" onmousedown=3D"this.hre=
f=3D'javascript:';return true;" onclick=3D"this.href=3D'javascr=
ipt:';return true;">wmx16...@163.com</a>></span> wrote:<br><blockquo=
te class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc so=
lid;padding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quo=
te" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-=
left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div><br></div><div>N=
ote that the current executor proposal to not necessarilly associate a requ=
irement to a specific interface. It would be possible</div><div>to have a r=
equirement not change the interface (but change the semantic).</div></div><=
/div></blockquote><div><br></div></span><div>I do not understand what you m=
ean by this=C2=A0paragraph. Could you please clarify it?</div></div></block=
quote><div><br></div><div>This is my understanding of the current executor =
proposal, so maybe I'm wrong but let's say that I want to introduce=
a new type of requirement:</div><div><br></div><div>struct MaybeOnline {};=
=C2=A0</div><div><br></div><div>I do not necessarilly have a specific inter=
face that an executor must provide. It might just expose a tag type to be d=
iscernable.</div><div>It might not introduce a member function, to be clear=
..</div><div><br></div><div>Just wanted that to be clear. The prerequisite t=
ypes does not seem to be interfaces themselves, they seem to be tags implyi=
ng interfaces.</div></div></div></div></blockquote><div><br></div><div>Than=
k you for the clarification.</div><div><br></div><div>From my point of view=
, the "tags" and the "interfaces" are different =E2=80=
=94 the "tags" defines the properties, and we are able to make de=
cisions with them (basically with `if-else` or `switch` statements); while =
the "interfaces" defines the functionality, that could be used un=
der specific preconditions (basically with templates or function pointers).=
</div><div><br></div><div>By the way, I do not think names like `operator b=
ool()` or `target_type()` in the polymorphic executor are more reasonable t=
han `has_value()` or `type()` in `std::any` or `static_addresser` in P0957.=
</div><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;m=
argin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=
=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=
=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=
=3D"ltr"><span><blockquote class=3D"gmail_quote" style=3D"margin:0;margin-l=
eft:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><di=
v class=3D"gmail_quote"><div>How do you provide the user any control if the=
y don't ajve access to what is controlling the underlying thread?</div>=
<div>Threads are resources, they have to be managed explicitely in some way=
s. Hiding them from the user is good but they still need to know what some =
will be created and where their lifetime will end.</div><div>Also, the user=
is usually concerned with the task, not the thread.</div></div></div></blo=
ckquote><div><br></div></span><div>As I replied to=C2=A0Mysen, I think it i=
s not necessary both for users and library implementators.</div><span><div>=
<br></div></span></div></blockquote><div>That do not match my experience, b=
ut maybe there is need for both.</div></div></div></blockquote><div><br></d=
iv><div>As an implementator, I think it may be acceptable to save the threa=
d objects in a thread pool with fixed number of worker threads. However, wh=
en it comes to dynamic thread pools, managing the thread objects would make=
the algorithm more complex =E2=80=94 at least, we need to store a more com=
plicated data structure (e.g., `std::set`, `std::unordered_set` or some loc=
k-free ones) than `std::vector`; when threads exit automatically, their obj=
ects shall also be detached. Still, there seems to be little motivation to =
do this if one is able to write concurrent code correctly. Thus I think we =
do not need both.</div><div><br></div><blockquote class=3D"gmail_quote" sty=
le=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left=
: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>You probably have =
enough background to make some proposals in this direction. Maybe contact M=
icheal Wong to see if you can help with the other potential thread-pool and=
executors proposals.</div></div></div></blockquote><div><br></div><div>Tha=
nk you for your=C2=A0recognition. Actually, I am a big fan of Michael Wong,=
and learnt C++11 with his book.</div><div><br></div><div>Recently, I have =
been trying to remove some existing concepts (e.g., Binary Semaphore and Ex=
ecution Agent Portal) in P0642 for the next revision. Since P0642 requires =
abstraction of execution, I believe its API would become more ease-to-use w=
ith the support of the Executors TS.</div><div><br></div><blockquote class=
=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #cc=
c solid;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><bl=
ockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #=
ccc solid;padding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gma=
il_quote" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;pa=
dding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>Well, all =
performant thread pools I know of use "work-stealing" algorithms =
which imply having 1 queue per thread</div><div>and the algorithm re-equili=
brate the workload depending on some parametters. I understand it is not tr=
ivial</div><div>and didn't attempt to implement one (in critical cases =
I would do like you, a "naive but working" one).</div><div><br></=
div><div>For example of such implementations, look at:</div><div>=C2=A0- In=
tel Threading Building Blocks;</div><div>=C2=A0- HPX;</div><div>=C2=A0- may=
be Boost.Thread experimental thread pool do work stealing, I'm not sure=
, I didn't check.</div></div></div></blockquote><div><br></div></span><=
div>As far as I am concered, "work-stealing" strategy is useful a=
lmost only when there are a lot of `wait` in our original code, and we want=
to reconstruct them within a short period to increase performance. However=
, "work-stealing" strategy=C2=A0is usually inefficient in well-de=
sign algorithms.</div></div></blockquote><div><br></div><div>My understandi=
ng is totally different: work-stealing does the workload balance for thread=
s in more efficient way than simpler algorithms for managing task queues.</=
div></div></div></blockquote><div><br></div><div>What do you mean by "=
in a more efficient way"? Do you mean the "Half Sync/Half Async&q=
uot; pattern? I am not quite familiar with the implementations you mentione=
d, but in Java, the "Fork Join Pool" seems not have such feature.=
</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin: 0=
;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div di=
r=3D"ltr"><div class=3D"gmail_quote"><div>It have nothing to do with waitin=
g, but it does have to do with the</div><div>unpredictable nature of execut=
ion time of varied kinds of work (so it's helful even when task impleme=
ntors persist with waiting).</div><div>It works well in the case we don'=
;t know what tasks will be executed and when. This is why most general-purp=
ose thread-pools are using some variant of work-stealing (as showed in the =
talk video).</div></div></div></blockquote><div><br></div><div>As far as I =
am concerned, work-stealing is about "executing irrelevant work while =
waiting". In the "Fork Join Pool" in Java, a task should alw=
ays wait for a forked task to be done with a specific API to work. The impl=
ementation registers the waiting thread to a internal data structure, and a=
ssigns tasks if available, resulting in possible delay for the waiting oper=
ation to unblock. All these works produce overhead.<br></div><div><br></div=
><div>However, if we use `async_concurrent_invoke` proposed in P0642, there=
won't be any blocking at all, and there will be little necessity to us=
e "work-stealing" strategy. As asynchronous programming will make=
it more complex to manage resources, especially execution agents, so a &qu=
ot;synchronous" version is also provided as `sync_concurrent_invoke`, =
where one could specify custom blocking algorithm, including the "work=
-stealing" if necessary. There is a more detailed analysis in P0642.</=
div><div><br></div><div>Honestly, I have not read the code of the facilitie=
s you mentioned, and I am not sure whether they have different mechanism to=
the "Fork Join Pool" in Java. If so, could you provide any relat=
ed code or document? Thank you.</div><div><br></div><blockquote class=3D"gm=
ail_quote" style=3D"margin: 0;margin-left: 0.8ex;border-left: 1px #ccc soli=
d;padding-left: 1ex;"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>So i=
f you are in a specialized case where tasks are very specific (like, all th=
e same with different parametters), then it's indeed less optimal than =
a specific executor/thread-pool etc.</div></div></div></blockquote></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/31ab339c-c7e5-4b3b-ac90-32d7440642b4%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/31ab339c-c7e5-4b3b-ac90-32d7440642b4=
%40isocpp.org</a>.<br />
------=_Part_27528_1948064371.1522862247483--
------=_Part_27527_1687849433.1522862247483--
.
Author: =?UTF-8?Q?Klaim_=2D_Jo=C3=ABl_Lamotte?= <mjklaim@gmail.com>
Date: Thu, 5 Apr 2018 01:12:03 +0200
Raw View
--000000000000de360005690df589
Content-Type: text/plain; charset="UTF-8"
On 4 April 2018 at 19:17, Mingxin Wang <wmx16835vv@163.com> wrote:
>
>> My understanding is totally different: work-stealing does the workload
>> balance for threads in more efficient way than simpler algorithms for
>> managing task queues.
>>
>
> What do you mean by "in a more efficient way"? Do you mean the "Half
> Sync/Half Async" pattern? I am not quite familiar with the implementations
> you mentioned, but in Java, the "Fork Join Pool" seems not have such
> feature.
>
>
Efficient way as in it's making sure threads not having work will do the
work queued for threads not finished with their current executing work.
It's more like flattening work over execution resources, therefore having a
change to execute all the work in the most efficeint way (assuming the
works don't sync on common data).
> It have nothing to do with waiting, but it does have to do with the
>> unpredictable nature of execution time of varied kinds of work (so it's
>> helful even when task implementors persist with waiting).
>> It works well in the case we don't know what tasks will be executed and
>> when. This is why most general-purpose thread-pools are using some variant
>> of work-stealing (as showed in the talk video).
>>
>
> As far as I am concerned, work-stealing is about "executing irrelevant
> work while waiting". In the "Fork Join Pool" in Java, a task should always
> wait for a forked task to be done with a specific API to work. The
> implementation registers the waiting thread to a internal data structure,
> and assigns tasks if available, resulting in possible delay for the waiting
> operation to unblock. All these works produce overhead.
>
>
I don't know what "Fork Join Pool" is in Java but just by the name it looks
like some kind of map/reduce algorithm? If yes, I think you might be mixing
how a thread pool manage workload (work-stealing)
and how to generate and manage work to be dispatched in (one or several)
executors (that might or might not be a thread pool) - (also see
std::reduce algorithm, bulk_execute examples in the design document for
executors and
Task Blocks in N4725).
If no, then I don't understand what you are talking about, sorry. ^^;
> However, if we use `async_concurrent_invoke` proposed in P0642, there
> won't be any blocking at all, and there will be little necessity to use
> "work-stealing" strategy. As asynchronous programming will make it more
> complex to manage resources, especially execution agents, so a
> "synchronous" version is also provided as `sync_concurrent_invoke`, where
> one could specify custom blocking algorithm, including the "work-stealing"
> if necessary. There is a more detailed analysis in P0642.
>
>
I don't see the relationship between work-stealing (which is an
implementation detail of how tasks are distributed through available
threads) and the rest of your points. Maybe I'm misunderstanding something.
> Honestly, I have not read the code of the facilities you mentioned, and I
> am not sure whether they have different mechanism to the "Fork Join Pool"
> in Java. If so, could you provide any related code or document? Thank you.
>
>
The simplest code I could show you is the one in Sean Parent's talk, which
is simple enough to be quickly understood.
> So if you are in a specialized case where tasks are very specific (like,
>> all the same with different parametters), then it's indeed less optimal
>> than a specific executor/thread-pool etc.
>>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/31ab339c-c7e5-4b3b-
> ac90-32d7440642b4%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/31ab339c-c7e5-4b3b-ac90-32d7440642b4%40isocpp.org?utm_medium=email&utm_source=footer>
> .
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OMZGKnBtr7UWqS3p%2Bf%3DJXwNXj474-t9wvaJUeTFEOrYtw%40mail.gmail.com.
--000000000000de360005690df589
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 4 April 2018 at 19:17, Mingxin Wang <span dir=3D"ltr"><<a href=3D=
"mailto:wmx16835vv@163.com" target=3D"_blank">wmx16835vv@163.com</a>></s=
pan> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0p=
x 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=
=3D"ltr"><span class=3D"gmail-"><blockquote class=3D"gmail_quote" style=3D"=
margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-lef=
t:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div><br></div><div>My u=
nderstanding is totally different: work-stealing does the workload balance =
for threads in more efficient way than simpler algorithms for managing task=
queues.</div></div></div></blockquote><div><br></div></span><div>What do y=
ou mean by "in a more efficient way"? Do you mean the "Half =
Sync/Half Async" pattern? I am not quite familiar with the implementat=
ions you mentioned, but in Java, the "Fork Join Pool" seems not h=
ave such feature.</div><span class=3D"gmail-"><div>=C2=A0</div></span></div=
></blockquote><div><br></div><div>Efficient way as in it's making sure =
threads not having work will do the work queued for threads not finished wi=
th their current executing work.</div><div>It's more like flattening wo=
rk over execution resources, therefore having a change to execute all the w=
ork in the most efficeint way (assuming the works don't sync on common =
data).</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"mar=
gin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1=
ex"><div dir=3D"ltr"><span class=3D"gmail-"><blockquote class=3D"gmail_quot=
e" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204)=
;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>It have=
nothing to do with waiting, but it does have to do with the</div><div>unpr=
edictable nature of execution time of varied kinds of work (so it's hel=
ful even when task implementors persist with waiting).</div><div>It works w=
ell in the case we don't know what tasks will be executed and when. Thi=
s is why most general-purpose thread-pools are using some variant of work-s=
tealing (as showed in the talk video).</div></div></div></blockquote><div><=
br></div></span><div>As far as I am concerned, work-stealing is about "=
;executing irrelevant work while waiting". In the "Fork Join Pool=
" in Java, a task should always wait for a forked task to be done with=
a specific API to work. The implementation registers the waiting thread to=
a internal data structure, and assigns tasks if available, resulting in po=
ssible delay for the waiting operation to unblock. All these works produce =
overhead.<br></div><div><br></div></div></blockquote><div><br></div><div>I =
don't know what "Fork Join Pool" is in Java but just by the n=
ame it looks like some kind of map/reduce algorithm? If yes, I think you mi=
ght be mixing how a thread pool manage workload (work-stealing)</div><div>a=
nd how to generate and manage work to be dispatched in (one or several) exe=
cutors (that might or might not be a thread pool) - (also see std::reduce a=
lgorithm,=C2=A0bulk_execute examples in the design document for executors a=
nd=C2=A0</div><div>Task Blocks in=C2=A0N4725).</div><div>If no, then I don&=
#39;t understand what you are talking about, sorry. ^^;</div><div><br></div=
><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px=
0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div di=
r=3D"ltr"><div></div><div>However, if we use `async_concurrent_invoke` prop=
osed in P0642, there won't be any blocking at all, and there will be li=
ttle necessity to use "work-stealing" strategy. As asynchronous p=
rogramming will make it more complex to manage resources, especially execut=
ion agents, so a "synchronous" version is also provided as `sync_=
concurrent_invoke`, where one could specify custom blocking algorithm, incl=
uding the "work-stealing" if necessary. There is a more detailed =
analysis in P0642.</div><div><br></div></div></blockquote><div><br></div><d=
iv>I don't see the relationship between work-stealing (which is an impl=
ementation detail of how tasks are distributed through available threads) a=
nd the rest of your points. Maybe I'm misunderstanding something.</div>=
<div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px =
0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=
=3D"ltr"><div></div><div>Honestly, I have not read the code of the faciliti=
es you mentioned, and I am not sure whether they have different mechanism t=
o the "Fork Join Pool" in Java. If so, could you provide any rela=
ted code or document? Thank you.</div><span class=3D"gmail-"><div><br></div=
></span></div></blockquote><div><br></div><div>The simplest code I could sh=
ow you is the one in Sean Parent's talk, which is simple enough to be q=
uickly understood.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" =
style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);pa=
dding-left:1ex"><div dir=3D"ltr"><span class=3D"gmail-"><div></div><blockqu=
ote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px=
solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gm=
ail_quote"><div>So if you are in a specialized case where tasks are very sp=
ecific (like, all the same with different parametters), then it's indee=
d less optimal than a specific executor/thread-pool etc.</div></div></div><=
/blockquote></span></div>
<p></p>
-- <br><span class=3D"gmail-">
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/31ab339c-c7e5-4b3b-ac90-32d7440642b4%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/31ab=
339c-c7e5-4b3b-<wbr>ac90-32d7440642b4%40isocpp.org</a><wbr>.<br>
</blockquote></div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOU91OMZGKnBtr7UWqS3p%2Bf%3DJXwNXj47=
4-t9wvaJUeTFEOrYtw%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter"=
>https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OMZGKnB=
tr7UWqS3p%2Bf%3DJXwNXj474-t9wvaJUeTFEOrYtw%40mail.gmail.com</a>.<br />
--000000000000de360005690df589--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Thu, 5 Apr 2018 09:18:40 -0700 (PDT)
Raw View
------=_Part_4958_891834618.1522945120580
Content-Type: multipart/alternative;
boundary="----=_Part_4959_1644674044.1522945120580"
------=_Part_4959_1644674044.1522945120580
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Thursday, April 5, 2018 at 7:12:46 AM UTC+8, Klaim - Jo=C3=ABl Lamotte w=
rote:
>
>
> On 4 April 2018 at 19:17, Mingxin Wang <wmx16...@163.com <javascript:>>=
=20
> wrote:
>
>>
>>> My understanding is totally different: work-stealing does the workload=
=20
>>> balance for threads in more efficient way than simpler algorithms for=
=20
>>> managing task queues.
>>>
>>
>> What do you mean by "in a more efficient way"? Do you mean the "Half=20
>> Sync/Half Async" pattern? I am not quite familiar with the implementatio=
ns=20
>> you mentioned, but in Java, the "Fork Join Pool" seems not have such=20
>> feature.
>> =20
>>
>
> Efficient way as in it's making sure threads not having work will do the=
=20
> work queued for threads not finished with their current executing work.
> It's more like flattening work over execution resources, therefore having=
=20
> a change to execute all the work in the most efficeint way (assuming the=
=20
> works don't sync on common data).
>
Do you mean the situation where worker threads have their unique working=20
queue? Actually, in my sample implementation above, there is only one=20
working queue, and it is always "load-balanced" within a thread pool=20
entity. I think it is not necessary to build working queues for each worker=
=20
thread most of the time (except for some cases in hardware, which are not=
=20
in the scope of our discussion), unless the frequency of task submission is=
=20
so high that could become a bottleneck, the monitor pattern (mutexies and=
=20
condition variables) will no longer feasible, and maybe we will need to=20
find a new synchronization mechanism (maybe with much lower level=20
primitives like the "futex" in POSIX). However, when there is no bottleneck=
=20
in task submission, I think there is no necessity to make the algorithm=20
more complex, which may introduce other weakness in performance or=20
extendibility.
=20
> It have nothing to do with waiting, but it does have to do with the
>>> unpredictable nature of execution time of varied kinds of work (so it's=
=20
>>> helful even when task implementors persist with waiting).
>>> It works well in the case we don't know what tasks will be executed and=
=20
>>> when. This is why most general-purpose thread-pools are using some vari=
ant=20
>>> of work-stealing (as showed in the talk video).
>>>
>>
>> As far as I am concerned, work-stealing is about "executing irrelevant=
=20
>> work while waiting". In the "Fork Join Pool" in Java, a task should alwa=
ys=20
>> wait for a forked task to be done with a specific API to work. The=20
>> implementation registers the waiting thread to a internal data structure=
,=20
>> and assigns tasks if available, resulting in possible delay for the wait=
ing=20
>> operation to unblock. All these works produce overhead.
>>
>>
> I don't know what "Fork Join Pool" is in Java but just by the name it=20
> looks like some kind of map/reduce algorithm? If yes, I think you might b=
e=20
> mixing how a thread pool manage workload (work-stealing)
> and how to generate and manage work to be dispatched in (one or several)=
=20
> executors (that might or might not be a thread pool) - (also see=20
> std::reduce algorithm, bulk_execute examples in the design document for=
=20
> executors and=20
> Task Blocks in N4725).
> If no, then I don't understand what you are talking about, sorry. ^^;
>
In simple terms, the "Fork Join Pool" in Java (aka. `class ForkJoinPool`=20
[1]) is a framework [2] that provides a pattern to "join" subtasks with=20
"work stealing" strategy. That is, stealing tasks from the depended thread=
=20
pool while waiting.
However, if we use `async_concurrent_invoke` proposed in P0642, there won't=
=20
>> be any blocking at all, and there will be little necessity to use=20
>> "work-stealing" strategy. As asynchronous programming will make it more=
=20
>> complex to manage resources, especially execution agents, so a=20
>> "synchronous" version is also provided as `sync_concurrent_invoke`, wher=
e=20
>> one could specify custom blocking algorithm, including the "work-stealin=
g"=20
>> if necessary. There is a more detailed analysis in P0642.
>>
>>
> I don't see the relationship between work-stealing (which is an=20
> implementation detail of how tasks are distributed through available=20
> threads) and the rest of your points. Maybe I'm misunderstanding somethin=
g.
> =20
>
>> Honestly, I have not read the code of the facilities you mentioned, and =
I=20
>> am not sure whether they have different mechanism to the "Fork Join Pool=
"=20
>> in Java. If so, could you provide any related code or document? Thank yo=
u.
>>
>>
> The simplest code I could show you is the one in Sean Parent's talk, whic=
h=20
> is simple enough to be quickly understood.
>
I am sorry that I am not able to watch the video on youtube (I am from=20
China, and the network speed is not enough to load the video from youtube=
=20
(=EF=BC=9E=EF=B9=8F=EF=BC=9C) ). Could you provide a snapshot or a copy of =
the code? Thank you!
[1] Java SE=20
API, https://docs.oracle.com/javase/10/docs/api/java/util/concurrent/ForkJo=
inPool.html.
[2] Lea, Doug. "A Java fork/join framework." *Proceedings of the ACM 2000=
=20
conference on Java Grande*. ACM, 2000.=20
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/8547ebde-b1f1-41ca-9454-69e6dfe974a6%40isocpp.or=
g.
------=_Part_4959_1644674044.1522945120580
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Thursday, April 5, 2018 at 7:12:46 AM UTC+8, Klaim - Jo=
=C3=ABl Lamotte wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;=
margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=
=3D"ltr"><div><br><div class=3D"gmail_quote">On 4 April 2018 at 19:17, Ming=
xin Wang <span dir=3D"ltr"><<a href=3D"javascript:" target=3D"_blank" gd=
f-obfuscated-mailto=3D"KSOmbFHyBQAJ" rel=3D"nofollow" onmousedown=3D"this.h=
ref=3D'javascript:';return true;" onclick=3D"this.href=3D'javas=
cript:';return true;">wmx16...@163.com</a>></span> wrote:<br><blockq=
uote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1p=
x solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span><blockquo=
te class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px =
solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gma=
il_quote"><div><br></div><div>My understanding is totally different: work-s=
tealing does the workload balance for threads in more efficient way than si=
mpler algorithms for managing task queues.</div></div></div></blockquote><d=
iv><br></div></span><div>What do you mean by "in a more efficient way&=
quot;? Do you mean the "Half Sync/Half Async" pattern? I am not q=
uite familiar with the implementations you mentioned, but in Java, the &quo=
t;Fork Join Pool" seems not have such feature.</div><span><div>=C2=A0<=
/div></span></div></blockquote><div><br></div><div>Efficient way as in it&#=
39;s making sure threads not having work will do the work queued for thread=
s not finished with their current executing work.</div><div>It's more l=
ike flattening work over execution resources, therefore having a change to =
execute all the work in the most efficeint way (assuming the works don'=
t sync on common data).</div></div></div></div></blockquote><div><br></div>=
<div>Do you mean the situation where worker threads have their unique worki=
ng queue? Actually, in my sample implementation above, there is only one wo=
rking queue, and it is always "load-balanced" within a thread poo=
l entity. I think it is not necessary to build working queues for each work=
er thread most of the time (except for some cases in hardware, which are no=
t in the scope of our discussion), unless the frequency of task submission =
is so high that could become a bottleneck, the monitor pattern (mutexies an=
d condition variables) will no longer feasible, and maybe we will need to f=
ind a new synchronization mechanism (maybe with much lower level primitives=
like the "futex" in POSIX). However, when there is no bottleneck=
in task submission, I think there is no necessity to make the algorithm mo=
re complex, which may introduce other weakness in performance or extendibil=
ity.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margi=
n: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><di=
v dir=3D"ltr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" =
style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);pa=
dding-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" st=
yle=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padd=
ing-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>It have noth=
ing to do with waiting, but it does have to do with the</div><div>unpredict=
able nature of execution time of varied kinds of work (so it's helful e=
ven when task implementors persist with waiting).</div><div>It works well i=
n the case we don't know what tasks will be executed and when. This is =
why most general-purpose thread-pools are using some variant of work-steali=
ng (as showed in the talk video).</div></div></div></blockquote><div><br></=
div></span><div>As far as I am concerned, work-stealing is about "exec=
uting irrelevant work while waiting". In the "Fork Join Pool"=
; in Java, a task should always wait for a forked task to be done with a sp=
ecific API to work. The implementation registers the waiting thread to a in=
ternal data structure, and assigns tasks if available, resulting in possibl=
e delay for the waiting operation to unblock. All these works produce overh=
ead.<br></div><div><br></div></div></blockquote><div><br></div><div>I don&#=
39;t know what "Fork Join Pool" is in Java but just by the name i=
t looks like some kind of map/reduce algorithm? If yes, I think you might b=
e mixing how a thread pool manage workload (work-stealing)</div><div>and ho=
w to generate and manage work to be dispatched in (one or several) executor=
s (that might or might not be a thread pool) - (also see std::reduce algori=
thm,=C2=A0bulk_execute examples in the design document for executors and=C2=
=A0</div><div>Task Blocks in=C2=A0N4725).</div><div>If no, then I don't=
understand what you are talking about, sorry. ^^;</div></div></div></block=
quote><div><br></div><div>In simple terms, the "Fork Join Pool" i=
n Java (aka. `class ForkJoinPool` [1]) is a framework [2] that provides a p=
attern to "join" subtasks with "work stealing" strategy=
.. That is, stealing tasks from the depended thread pool while waiting.</div=
><div><br></div><blockquote class=3D"gmail_quote" style=3D"margin: 0;margin=
-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"lt=
r"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"ma=
rgin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:=
1ex"><div dir=3D"ltr"><div></div><div>However, if we use `async_concurrent_=
invoke` proposed in P0642, there won't be any blocking at all, and ther=
e will be little necessity to use "work-stealing" strategy. As as=
ynchronous programming will make it more complex to manage resources, espec=
ially execution agents, so a "synchronous" version is also provid=
ed as `sync_concurrent_invoke`, where one could specify custom blocking alg=
orithm, including the "work-stealing" if necessary. There is a mo=
re detailed analysis in P0642.</div><div><br></div></div></blockquote><div>=
<br></div><div>I don't see the relationship between work-stealing (whic=
h is an implementation detail of how tasks are distributed through availabl=
e threads) and the rest of your points. Maybe I'm misunderstanding some=
thing.</div><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"mar=
gin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1=
ex"><div dir=3D"ltr"><div></div><div>Honestly, I have not read the code of =
the facilities you mentioned, and I am not sure whether they have different=
mechanism to the "Fork Join Pool" in Java. If so, could you prov=
ide any related code or document? Thank you.</div><span><div><br></div></sp=
an></div></blockquote><div><br></div><div>The simplest code I could show yo=
u is the one in Sean Parent's talk, which is simple enough to be quickl=
y understood.</div></div></div></blockquote><div><br></div><div>I am sorry =
that I am not able to watch the video on youtube (I am from China, and the =
network speed is not enough to load the video from youtube (=EF=BC=9E=EF=B9=
=8F=EF=BC=9C)=C2=A0). Could you provide a snapshot or a copy of the code? T=
hank you!</div><div><br></div><div>[1] Java SE API,=C2=A0https://docs.oracl=
e.com/javase/10/docs/api/java/util/concurrent/ForkJoinPool.html.</div><div>=
[2]=C2=A0<span style=3D"font-family: Arial, sans-serif;">Lea, Doug. "A=
Java fork/join framework."=C2=A0</span><i style=3D"font-family: Arial=
, sans-serif;">Proceedings of the ACM 2000 conference on Java Grande</i><sp=
an style=3D"font-family: Arial, sans-serif;">. ACM, 2000.</span>=C2=A0</div=
></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/8547ebde-b1f1-41ca-9454-69e6dfe974a6%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/8547ebde-b1f1-41ca-9454-69e6dfe974a6=
%40isocpp.org</a>.<br />
------=_Part_4959_1644674044.1522945120580--
------=_Part_4958_891834618.1522945120580--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Thu, 5 Apr 2018 09:42:08 -0700 (PDT)
Raw View
------=_Part_4903_1660011904.1522946528738
Content-Type: multipart/alternative;
boundary="----=_Part_4904_720576937.1522946528738"
------=_Part_4904_720576937.1522946528738
Content-Type: text/plain; charset="UTF-8"
On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wrote:
>
> A simple example of where properties do not change the concrete interface
> (and would not be detectable without the trait) is in the proposal as the
> blocking property:
>
> The `blocking_t` property describes what guarantees executors provide about the blocking behavior of their execution functions.
>
> `blocking_t` provides nested property types and objects as described below.
>
> | Nested Property Type | Nested Property Object Name | Requirements |
> |--------------------------|------------------------|--------------|
> | `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor's execution function may block pending completion of one or more of the execution agents created by that execution function. |
> | `blocking_t::always_t` | `blocking_t::always` | A call to an executor's execution function shall block until completion of all execution agents created by that execution function. |
> | `blocking_t::never_t` | `blocking_t::never` | A call to an executor's execution function shall not block pending completion of the execution agents created by that execution function. |
>
>
> This is a very important property because it is vitally important that I
> can push a continuation into an executor such a guarantee that it will not
> block the caller. An inline executor would not satisfy that property,
> because it would block until the function is complete. An executor with a
> logically infinite queue can guarantee that it is non-blocking, and should
> say so.
>
> The execute function looks the same but I can use that trait as a filter
> on what executor my library accepts.
>
I see. It do be necessary for users.
By the way, I think maybe we could define the semantics of bulk execution
like:
A type E meets the BulkOnewayExecutor requirements if the following
expressions are well-formed and have the specified semantics (e denotes a
value of type E).
e.bulk_execute(funcs)
Requires: `funcs` shall be random accessable (funcs[i] represents a
Callable type for each `i` of type `std::size_t` in range `[0,
funcs.size())`), or otherwise be iterable (funcs.begin(), funcs.end() shall
be well-formed and have specific semantics...).
Effects: Perform `DECAY_COPY(funcs[i])()` for each `i` of type
`std::size_t` in range `[0, funcs.size())` if `funcs` is random accessable,
or perform `DECAY_COPY(f)()` for each `f` in the for-range loop `for (autp&
f : funcs)`.
I think that would be more ease-to-use than `x.bulk_execute(f, n, sf)`. I
am looking forward to your comments!
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%40isocpp.org.
------=_Part_4904_720576937.1522946528738
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes=
wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.=
8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr">A simp=
le example of where properties do not change the concrete interface (and wo=
uld not be detectable without the trait) is in the proposal as the blocking=
property:<div><pre style=3D"color:rgb(0,0,0);font-style:normal;font-weight=
:400;letter-spacing:normal;text-align:start;text-indent:0px;text-transform:=
none;word-spacing:0px;word-wrap:break-word;white-space:pre-wrap">The `block=
ing_t` property describes what guarantees executors provide about the block=
ing behavior of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|--<wbr>----------------------|-------<wbr>-----=
--|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor=
's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an executor'=
;s execution function shall block until completion of all execution agents =
created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |</pre></div><div><br></div><div>Th=
is is a very important property because it is vitally important that I can =
push a continuation into an executor such a guarantee that it will not bloc=
k the caller. An inline executor would not satisfy that property, because i=
t would block until the function is complete. An executor with a logically =
infinite queue can guarantee that it is non-blocking, and should say so.</d=
iv><div><br></div><div>The execute function looks the same but I can use th=
at trait as a filter on what executor my library accepts.</div></div></bloc=
kquote><div><br></div><div>I see. It do be necessary for users.</div><div><=
br></div><div>By the way, I think maybe we could define the semantics of bu=
lk execution like:=C2=A0</div><div><br></div><div><div class=3D"prettyprint=
" style=3D"background-color: rgb(250, 250, 250); border-color: rgb(187, 187=
, 187); border-style: solid; border-width: 1px; word-wrap: break-word;"><co=
de class=3D"prettyprint"><div class=3D"subprettyprint"><font color=3D"#6600=
66"><div class=3D"subprettyprint">A type E meets the BulkOnewayExecutor req=
uirements if the following expressions are well-formed and have the specifi=
ed semantics (e denotes a value of type E).</div><div class=3D"subprettypri=
nt"><br></div><div class=3D"subprettyprint">e.bulk_execute(funcs)</div><div=
class=3D"subprettyprint">=C2=A0 Requires: `funcs` shall be random accessab=
le (funcs[i] represents a Callable type for each `i` of type `std::size_t` =
in range `[0, funcs.size())`), or otherwise be iterable (funcs.begin(), fun=
cs.end() shall be well-formed and have specific semantics...).</div><div cl=
ass=3D"subprettyprint">=C2=A0 Effects: Perform `DECAY_COPY(funcs[i])()` for=
each `i` of type `std::size_t` in range `[0, funcs.size())` if `funcs` is =
random accessable, or perform `DECAY_COPY(f)()` for each `f` in the for-ran=
ge loop `for (autp& f : funcs)`.</div></font></div></code></div><br>I t=
hink that would be more ease-to-use than `x.bulk_execute(f, n, sf)`. I am l=
ooking forward to your comments!</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746=
%40isocpp.org</a>.<br />
------=_Part_4904_720576937.1522946528738--
------=_Part_4903_1660011904.1522946528738--
.
Author: =?UTF-8?Q?Micha=C5=82_Dominiak?= <griwes@griwes.info>
Date: Thu, 05 Apr 2018 17:55:56 +0000
Raw View
--001a114dd4d06db03905691da719
Content-Type: text/plain; charset="UTF-8"
On Thu, Apr 5, 2018 at 6:42 PM Mingxin Wang <wmx16835vv@163.com> wrote:
> On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wrote:
>>
>> A simple example of where properties do not change the concrete interface
>> (and would not be detectable without the trait) is in the proposal as the
>> blocking property:
>>
>> The `blocking_t` property describes what guarantees executors provide about the blocking behavior of their execution functions.
>>
>> `blocking_t` provides nested property types and objects as described below.
>>
>> | Nested Property Type | Nested Property Object Name | Requirements |
>> |--------------------------|------------------------|--------------|
>> | `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor's execution function may block pending completion of one or more of the execution agents created by that execution function. |
>> | `blocking_t::always_t` | `blocking_t::always` | A call to an executor's execution function shall block until completion of all execution agents created by that execution function. |
>> | `blocking_t::never_t` | `blocking_t::never` | A call to an executor's execution function shall not block pending completion of the execution agents created by that execution function. |
>>
>>
>> This is a very important property because it is vitally important that I
>> can push a continuation into an executor such a guarantee that it will not
>> block the caller. An inline executor would not satisfy that property,
>> because it would block until the function is complete. An executor with a
>> logically infinite queue can guarantee that it is non-blocking, and should
>> say so.
>>
>> The execute function looks the same but I can use that trait as a filter
>> on what executor my library accepts.
>>
>
> I see. It do be necessary for users.
>
> By the way, I think maybe we could define the semantics of bulk execution
> like:
>
> A type E meets the BulkOnewayExecutor requirements if the following
> expressions are well-formed and have the specified semantics (e denotes a
> value of type E).
>
> e.bulk_execute(funcs)
> Requires: `funcs` shall be random accessable (funcs[i] represents a
> Callable type for each `i` of type `std::size_t` in range `[0,
> funcs.size())`), or otherwise be iterable (funcs.begin(), funcs.end() shall
> be well-formed and have specific semantics...).
> Effects: Perform `DECAY_COPY(funcs[i])()` for each `i` of type
> `std::size_t` in range `[0, funcs.size())` if `funcs` is random accessable,
> or perform `DECAY_COPY(f)()` for each `f` in the for-range loop `for (autp&
> f : funcs)`.
>
> I think that would be more ease-to-use than `x.bulk_execute(f, n, sf)`. I
> am looking forward to your comments!
>
Now I have to create a range of functions to be able to bulk execute, where
previously I could just have a function and some context arguments. This is
way more complex to use than the current interface (even if you need a
dummy `fs`).
Remember that executors are the low-level building blocks for more complex
library facilities. The lowlevelness of this API is perfectly fine. (I can
imagine a lot of users of `bulk_execute` will return a tuple from `fs` and
`std::apply` with it somewhere in `f`. I *can't* imagine too many users
using `bulk_execute` directly from an *application*. (If those assumptions
are wrong, I will stand corrected - but that's what I understand the
assumptions made by the paper to be.))
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit
> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%40isocpp.org?utm_medium=email&utm_source=footer>
> .
>
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9JncZJvLSF4YJ4DsCX09A_dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com.
--001a114dd4d06db03905691da719
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><div class=3D"gmail_quote"><div dir=3D"ltr">On Thu, Apr 5,=
2018 at 6:42 PM Mingxin Wang <<a href=3D"mailto:wmx16835vv@163.com">wmx=
16835vv@163.com</a>> wrote:<br></div><blockquote class=3D"gmail_quote" s=
tyle=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div=
dir=3D"ltr">On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wro=
te:<blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;bo=
rder-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr">A simple exampl=
e of where properties do not change the concrete interface (and would not b=
e detectable without the trait) is in the proposal as the blocking property=
:<div><pre style=3D"color:rgb(0,0,0);font-style:normal;font-weight:400;lett=
er-spacing:normal;text-align:start;text-indent:0px;text-transform:none;word=
-spacing:0px;word-wrap:break-word;white-space:pre-wrap">The `blocking_t` pr=
operty describes what guarantees executors provide about the blocking behav=
ior of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|------------------------|--------------|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor=
's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an executor'=
;s execution function shall block until completion of all execution agents =
created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |</pre></div><div><br></div><div>Th=
is is a very important property because it is vitally important that I can =
push a continuation into an executor such a guarantee that it will not bloc=
k the caller. An inline executor would not satisfy that property, because i=
t would block until the function is complete. An executor with a logically =
infinite queue can guarantee that it is non-blocking, and should say so.</d=
iv><div><br></div><div>The execute function looks the same but I can use th=
at trait as a filter on what executor my library accepts.</div></div></bloc=
kquote><div><br></div></div><div dir=3D"ltr"><div>I see. It do be necessary=
for users.</div><div><br></div><div>By the way, I think maybe we could def=
ine the semantics of bulk execution like:=C2=A0</div><div><br></div><div><d=
iv class=3D"m_-4088449540241721455prettyprint" style=3D"background-color:rg=
b(250,250,250);border-color:rgb(187,187,187);border-style:solid;border-widt=
h:1px;word-wrap:break-word"><code class=3D"m_-4088449540241721455prettyprin=
t"><div class=3D"m_-4088449540241721455subprettyprint"><font color=3D"#6600=
66"><div class=3D"m_-4088449540241721455subprettyprint">A type E meets the =
BulkOnewayExecutor requirements if the following expressions are well-forme=
d and have the specified semantics (e denotes a value of type E).</div><div=
class=3D"m_-4088449540241721455subprettyprint"><br></div><div class=3D"m_-=
4088449540241721455subprettyprint">e.bulk_execute(funcs)</div><div class=3D=
"m_-4088449540241721455subprettyprint">=C2=A0 Requires: `funcs` shall be ra=
ndom accessable (funcs[i] represents a Callable type for each `i` of type `=
std::size_t` in range `[0, funcs.size())`), or otherwise be iterable (funcs=
..begin(), funcs.end() shall be well-formed and have specific semantics...).=
</div><div class=3D"m_-4088449540241721455subprettyprint">=C2=A0 Effects: P=
erform `DECAY_COPY(funcs[i])()` for each `i` of type `std::size_t` in range=
`[0, funcs.size())` if `funcs` is random accessable, or perform `DECAY_COP=
Y(f)()` for each `f` in the for-range loop `for (autp& f : funcs)`.</di=
v></font></div></code></div><br>I think that would be more ease-to-use than=
`x.bulk_execute(f, n, sf)`. I am looking forward to your comments!</div></=
div></blockquote><div><br></div><div>Now I have to create a range of functi=
ons to be able to bulk execute, where previously I could just have a functi=
on and some context arguments. This is way more complex to use than the cur=
rent interface (even if you need a dummy `fs`).</div><div><br></div><div>Re=
member that executors are the low-level building blocks for more complex li=
brary facilities. The lowlevelness of this API is perfectly fine. (I can im=
agine a lot of users of `bulk_execute` will return a tuple from `fs` and `s=
td::apply` with it somewhere in `f`. I <i>can't</i>=C2=A0imagine too ma=
ny users using `bulk_execute` directly from an <i>application</i>. (If thos=
e assumptions are wrong, I will stand corrected - but that's what I und=
erstand the assumptions made by the paper to be.))</div><div>=C2=A0</div><b=
lockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px =
#ccc solid;padding-left:1ex">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-=
4911-9006-3198cc8db746%40isocpp.org</a>.<br>
</blockquote></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9JncZJvLSF4YJ4DsCX09A_dm7n9g=
UgEsD3f7W5TJRQ%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">htt=
ps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9JncZJvL=
SF4YJ4DsCX09A_dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com</a>.<br />
--001a114dd4d06db03905691da719--
.
Author: Lee Howes <xrikcus@gmail.com>
Date: Thu, 5 Apr 2018 11:25:54 -0700
Raw View
--001a113ec1e4fec8c805691e11ba
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
Worse than that, unless we had some way to prove that every function in the
list was identically, compiled to the same token sequence and could be
effectively merged, we might as well not have bulk_execute at all because
it wouldn't work for the intended use cases.
On 5 April 2018 at 10:55, Micha=C5=82 Dominiak <griwes@griwes.info> wrote:
> On Thu, Apr 5, 2018 at 6:42 PM Mingxin Wang <wmx16835vv@163.com> wrote:
>
>> On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wrote:
>>>
>>> A simple example of where properties do not change the concrete
>>> interface (and would not be detectable without the trait) is in the
>>> proposal as the blocking property:
>>>
>>> The `blocking_t` property describes what guarantees executors provide a=
bout the blocking behavior of their execution functions.
>>>
>>> `blocking_t` provides nested property types and objects as described be=
low.
>>>
>>> | Nested Property Type | Nested Property Object Name | Requirements |
>>> |--------------------------|------------------------|--------------|
>>> | `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an exec=
utor's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
>>> | `blocking_t::always_t` | `blocking_t::always` | A call to an executor=
's execution function shall block until completion of all execution agents =
created by that execution function. |
>>> | `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |
>>>
>>>
>>> This is a very important property because it is vitally important that =
I
>>> can push a continuation into an executor such a guarantee that it will =
not
>>> block the caller. An inline executor would not satisfy that property,
>>> because it would block until the function is complete. An executor with=
a
>>> logically infinite queue can guarantee that it is non-blocking, and sho=
uld
>>> say so.
>>>
>>> The execute function looks the same but I can use that trait as a filte=
r
>>> on what executor my library accepts.
>>>
>>
>> I see. It do be necessary for users.
>>
>> By the way, I think maybe we could define the semantics of bulk executio=
n
>> like:
>>
>> A type E meets the BulkOnewayExecutor requirements if the following
>> expressions are well-formed and have the specified semantics (e denotes =
a
>> value of type E).
>>
>> e.bulk_execute(funcs)
>> Requires: `funcs` shall be random accessable (funcs[i] represents a
>> Callable type for each `i` of type `std::size_t` in range `[0,
>> funcs.size())`), or otherwise be iterable (funcs.begin(), funcs.end() sh=
all
>> be well-formed and have specific semantics...).
>> Effects: Perform `DECAY_COPY(funcs[i])()` for each `i` of type
>> `std::size_t` in range `[0, funcs.size())` if `funcs` is random accessab=
le,
>> or perform `DECAY_COPY(f)()` for each `f` in the for-range loop `for (au=
tp&
>> f : funcs)`.
>>
>> I think that would be more ease-to-use than `x.bulk_execute(f, n, sf)`. =
I
>> am looking forward to your comments!
>>
>
> Now I have to create a range of functions to be able to bulk execute,
> where previously I could just have a function and some context arguments.
> This is way more complex to use than the current interface (even if you
> need a dummy `fs`).
>
> Remember that executors are the low-level building blocks for more comple=
x
> library facilities. The lowlevelness of this API is perfectly fine. (I ca=
n
> imagine a lot of users of `bulk_execute` will return a tuple from `fs` an=
d
> `std::apply` with it somewhere in `f`. I *can't* imagine too many users
> using `bulk_execute` directly from an *application*. (If those
> assumptions are wrong, I will stand corrected - but that's what I
> understand the assumptions made by the paper to be.))
>
>
>> --
>> You received this message because you are subscribed to the Google Group=
s
>> "ISO C++ Standard - Future Proposals" group.
>> To unsubscribe from this group and stop receiving emails from it, send a=
n
>> email to std-proposals+unsubscribe@isocpp.org.
>> To post to this group, send email to std-proposals@isocpp.org.
>> To view this discussion on the web visit https://groups.google.com/a/
>> isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-
>> 9006-3198cc8db746%40isocpp.org
>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d=
4b3-4911-9006-3198cc8db746%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoo=
ter>
>> .
>>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/CAPCFJdTF9JncZJvLSF4YJ4DsCX09A
> _dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9J=
ncZJvLSF4YJ4DsCX09A_dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com?utm_medium=3Demai=
l&utm_source=3Dfooter>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAJH_FNU4cvBYek4XptAz7HDJZfuQaP8V3yECTv1qE5f5O%3=
DVGbA%40mail.gmail.com.
--001a113ec1e4fec8c805691e11ba
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">Worse than that, unless we had some way to prove that ever=
y function in the list was identically, compiled to the same token sequence=
and could be effectively merged, we might as well not have bulk_execute at=
all because it wouldn't work for the intended use cases.<div><br></div=
></div><div class=3D"gmail_extra"><br><div class=3D"gmail_quote">On 5 April=
2018 at 10:55, Micha=C5=82 Dominiak <span dir=3D"ltr"><<a href=3D"mailt=
o:griwes@griwes.info" target=3D"_blank">griwes@griwes.info</a>></span> w=
rote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;borde=
r-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmai=
l_quote"><span class=3D""><div dir=3D"ltr">On Thu, Apr 5, 2018 at 6:42 PM M=
ingxin Wang <<a href=3D"mailto:wmx16835vv@163.com" target=3D"_blank">wmx=
16835vv@163.com</a>> wrote:<br></div><blockquote class=3D"gmail_quote" s=
tyle=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div=
dir=3D"ltr">On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wro=
te:<blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;bo=
rder-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr">A simple exampl=
e of where properties do not change the concrete interface (and would not b=
e detectable without the trait) is in the proposal as the blocking property=
:<div><pre style=3D"color:rgb(0,0,0);font-style:normal;font-weight:400;lett=
er-spacing:normal;text-align:start;text-indent:0px;text-transform:none;word=
-spacing:0px;word-wrap:break-word;white-space:pre-wrap">The `blocking_t` pr=
operty describes what guarantees executors provide about the blocking behav=
ior of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|--<wbr>----------------------|-------<wbr>-----=
--|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor=
's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an executor'=
;s execution function shall block until completion of all execution agents =
created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |</pre></div><div><br></div><div>Th=
is is a very important property because it is vitally important that I can =
push a continuation into an executor such a guarantee that it will not bloc=
k the caller. An inline executor would not satisfy that property, because i=
t would block until the function is complete. An executor with a logically =
infinite queue can guarantee that it is non-blocking, and should say so.</d=
iv><div><br></div><div>The execute function looks the same but I can use th=
at trait as a filter on what executor my library accepts.</div></div></bloc=
kquote><div><br></div></div><div dir=3D"ltr"><div>I see. It do be necessary=
for users.</div><div><br></div><div>By the way, I think maybe we could def=
ine the semantics of bulk execution like:=C2=A0</div><div><br></div><div><d=
iv class=3D"m_3189367164318302795m_-4088449540241721455prettyprint" style=
=3D"background-color:rgb(250,250,250);border-color:rgb(187,187,187);border-=
style:solid;border-width:1px;word-wrap:break-word"><code class=3D"m_3189367=
164318302795m_-4088449540241721455prettyprint"><div class=3D"m_318936716431=
8302795m_-4088449540241721455subprettyprint"><font color=3D"#660066"><div c=
lass=3D"m_3189367164318302795m_-4088449540241721455subprettyprint">A type E=
meets the BulkOnewayExecutor requirements if the following expressions are=
well-formed and have the specified semantics (e denotes a value of type E)=
..</div><div class=3D"m_3189367164318302795m_-4088449540241721455subprettypr=
int"><br></div><div class=3D"m_3189367164318302795m_-4088449540241721455sub=
prettyprint">e.bulk_execute(funcs)</div><div class=3D"m_3189367164318302795=
m_-4088449540241721455subprettyprint">=C2=A0 Requires: `funcs` shall be ran=
dom accessable (funcs[i] represents a Callable type for each `i` of type `s=
td::size_t` in range `[0, funcs.size())`), or otherwise be iterable (funcs.=
begin(), funcs.end() shall be well-formed and have specific semantics...).<=
/div><div class=3D"m_3189367164318302795m_-4088449540241721455subprettyprin=
t">=C2=A0 Effects: Perform `DECAY_COPY(funcs[i])()` for each `i` of type `s=
td::size_t` in range `[0, funcs.size())` if `funcs` is random accessable, o=
r perform `DECAY_COPY(f)()` for each `f` in the for-range loop `for (autp&a=
mp; f : funcs)`.</div></font></div></code></div><br>I think that would be m=
ore ease-to-use than `x.bulk_execute(f, n, sf)`. I am looking forward to yo=
ur comments!</div></div></blockquote><div><br></div></span><div>Now I have =
to create a range of functions to be able to bulk execute, where previously=
I could just have a function and some context arguments. This is way more =
complex to use than the current interface (even if you need a dummy `fs`).<=
/div><div><br></div><div>Remember that executors are the low-level building=
blocks for more complex library facilities. The lowlevelness of this API i=
s perfectly fine. (I can imagine a lot of users of `bulk_execute` will retu=
rn a tuple from `fs` and `std::apply` with it somewhere in `f`. I <i>can=
9;t</i>=C2=A0imagine too many users using `bulk_execute` directly from an <=
i>application</i>. (If those assumptions are wrong, I will stand corrected =
- but that's what I understand the assumptions made by the paper to be.=
))</div><span class=3D""><div>=C2=A0</div><blockquote class=3D"gmail_quote"=
style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/788b=
309c-d4b3-4911-<wbr>9006-3198cc8db746%40isocpp.org</a><wbr>.<br>
</blockquote></span></div></div><span class=3D"">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9JncZJvLSF4YJ4DsCX09A_dm7n9g=
UgEsD3f7W5TJRQ%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter"=
target=3D"_blank">https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-=
<wbr>proposals/<wbr>CAPCFJdTF9JncZJvLSF4YJ4DsCX09A<wbr>_dm7n9gUgEsD3f7W5TJR=
Q%40mail.<wbr>gmail.com</a>.<br>
</blockquote></div><br></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAJH_FNU4cvBYek4XptAz7HDJZfuQaP8V3yEC=
Tv1qE5f5O%3DVGbA%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNU4cvBYek=
4XptAz7HDJZfuQaP8V3yECTv1qE5f5O%3DVGbA%40mail.gmail.com</a>.<br />
--001a113ec1e4fec8c805691e11ba--
.
Author: =?UTF-8?Q?Micha=C5=82_Dominiak?= <griwes@griwes.info>
Date: Thu, 05 Apr 2018 18:39:47 +0000
Raw View
--001a114dd4d03c1fab05691e445d
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
D'oh. Me not being one of the resident GPU people really is showing, isn't
it? :D
On Thu, Apr 5, 2018, 8:25 PM Lee Howes <xrikcus@gmail.com> wrote:
> Worse than that, unless we had some way to prove that every function in
> the list was identically, compiled to the same token sequence and could b=
e
> effectively merged, we might as well not have bulk_execute at all because
> it wouldn't work for the intended use cases.
>
>
> On 5 April 2018 at 10:55, Micha=C5=82 Dominiak <griwes@griwes.info> wrote=
:
>
>> On Thu, Apr 5, 2018 at 6:42 PM Mingxin Wang <wmx16835vv@163.com> wrote:
>>
>>> On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wrote:
>>>>
>>>> A simple example of where properties do not change the concrete
>>>> interface (and would not be detectable without the trait) is in the
>>>> proposal as the blocking property:
>>>>
>>>> The `blocking_t` property describes what guarantees executors provide =
about the blocking behavior of their execution functions.
>>>>
>>>> `blocking_t` provides nested property types and objects as described b=
elow.
>>>>
>>>> | Nested Property Type | Nested Property Object Name | Requirements |
>>>> |--------------------------|------------------------|--------------|
>>>> | `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an exe=
cutor's execution function may block pending completion of one or more of t=
he execution agents created by that execution function. |
>>>> | `blocking_t::always_t` | `blocking_t::always` | A call to an executo=
r's execution function shall block until completion of all execution agents=
created by that execution function. |
>>>> | `blocking_t::never_t` | `blocking_t::never` | A call to an executor'=
s execution function shall not block pending completion of the execution ag=
ents created by that execution function. |
>>>>
>>>>
>>>> This is a very important property because it is vitally important that
>>>> I can push a continuation into an executor such a guarantee that it wi=
ll
>>>> not block the caller. An inline executor would not satisfy that proper=
ty,
>>>> because it would block until the function is complete. An executor wit=
h a
>>>> logically infinite queue can guarantee that it is non-blocking, and sh=
ould
>>>> say so.
>>>>
>>>> The execute function looks the same but I can use that trait as a
>>>> filter on what executor my library accepts.
>>>>
>>>
>>> I see. It do be necessary for users.
>>>
>>> By the way, I think maybe we could define the semantics of bulk
>>> execution like:
>>>
>>> A type E meets the BulkOnewayExecutor requirements if the following
>>> expressions are well-formed and have the specified semantics (e denotes=
a
>>> value of type E).
>>>
>>> e.bulk_execute(funcs)
>>> Requires: `funcs` shall be random accessable (funcs[i] represents a
>>> Callable type for each `i` of type `std::size_t` in range `[0,
>>> funcs.size())`), or otherwise be iterable (funcs.begin(), funcs.end() s=
hall
>>> be well-formed and have specific semantics...).
>>> Effects: Perform `DECAY_COPY(funcs[i])()` for each `i` of type
>>> `std::size_t` in range `[0, funcs.size())` if `funcs` is random accessa=
ble,
>>> or perform `DECAY_COPY(f)()` for each `f` in the for-range loop `for (a=
utp&
>>> f : funcs)`.
>>>
>>> I think that would be more ease-to-use than `x.bulk_execute(f, n, sf)`.
>>> I am looking forward to your comments!
>>>
>>
>> Now I have to create a range of functions to be able to bulk execute,
>> where previously I could just have a function and some context arguments=
..
>> This is way more complex to use than the current interface (even if you
>> need a dummy `fs`).
>>
>> Remember that executors are the low-level building blocks for more
>> complex library facilities. The lowlevelness of this API is perfectly fi=
ne.
>> (I can imagine a lot of users of `bulk_execute` will return a tuple from
>> `fs` and `std::apply` with it somewhere in `f`. I *can't* imagine too
>> many users using `bulk_execute` directly from an *application*. (If
>> those assumptions are wrong, I will stand corrected - but that's what I
>> understand the assumptions made by the paper to be.))
>>
>>
>>> --
>>> You received this message because you are subscribed to the Google
>>> Groups "ISO C++ Standard - Future Proposals" group.
>>> To unsubscribe from this group and stop receiving emails from it, send
>>> an email to std-proposals+unsubscribe@isocpp.org.
>>> To post to this group, send email to std-proposals@isocpp.org.
>>> To view this discussion on the web visit
>>> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d=
4b3-4911-9006-3198cc8db746%40isocpp.org
>>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-=
d4b3-4911-9006-3198cc8db746%40isocpp.org?utm_medium=3Demail&utm_source=3Dfo=
oter>
>>> .
>>>
>> --
>> You received this message because you are subscribed to the Google Group=
s
>> "ISO C++ Standard - Future Proposals" group.
>> To unsubscribe from this group and stop receiving emails from it, send a=
n
>> email to std-proposals+unsubscribe@isocpp.org.
>> To post to this group, send email to std-proposals@isocpp.org.
>>
> To view this discussion on the web visit
>> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9J=
ncZJvLSF4YJ4DsCX09A_dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com
>> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9=
JncZJvLSF4YJ4DsCX09A_dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com?utm_medium=3Dema=
il&utm_source=3Dfooter>
>> .
>>
>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit
> https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNU4cvB=
Yek4XptAz7HDJZfuQaP8V3yECTv1qE5f5O%3DVGbA%40mail.gmail.com
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAJH_FNU4cv=
BYek4XptAz7HDJZfuQaP8V3yECTv1qE5f5O%3DVGbA%40mail.gmail.com?utm_medium=3Dem=
ail&utm_source=3Dfooter>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAPCFJdT-9dcOJMEXDVhQTp42N2rTBGtW8ww_67OUvxu5iVH=
s%3DA%40mail.gmail.com.
--001a114dd4d03c1fab05691e445d
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
D'oh. Me not being one of the resident GPU people really is showing, is=
n't it? :D<br><br><div class=3D"gmail_quote"><div dir=3D"ltr">On Thu, A=
pr 5, 2018, 8:25 PM Lee Howes <<a href=3D"mailto:xrikcus@gmail.com">xrik=
cus@gmail.com</a>> wrote:<br></div><blockquote class=3D"gmail_quote" sty=
le=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex"><div d=
ir=3D"ltr">Worse than that, unless we had some way to prove that every func=
tion in the list was identically, compiled to the same token sequence and c=
ould be effectively merged, we might as well not have bulk_execute at all b=
ecause it wouldn't work for the intended use cases.<div><br></div></div=
><div class=3D"gmail_extra"><br><div class=3D"gmail_quote"></div></div><div=
class=3D"gmail_extra"><div class=3D"gmail_quote">On 5 April 2018 at 10:55,=
Micha=C5=82 Dominiak <span dir=3D"ltr"><<a href=3D"mailto:griwes@griwes=
..info" target=3D"_blank">griwes@griwes.info</a>></span> wrote:<br></div>=
</div><div class=3D"gmail_extra"><div class=3D"gmail_quote"><blockquote cla=
ss=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;pa=
dding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><span><div dir=
=3D"ltr">On Thu, Apr 5, 2018 at 6:42 PM Mingxin Wang <<a href=3D"mailto:=
wmx16835vv@163.com" target=3D"_blank">wmx16835vv@163.com</a>> wrote:<br>=
</div><blockquote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-l=
eft:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr">On Wednesday, April 4=
, 2018 at 4:50:10 AM UTC+8, Lee Howes wrote:<blockquote class=3D"gmail_quot=
e" style=3D"margin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-l=
eft:1ex"><div dir=3D"ltr">A simple example of where properties do not chang=
e the concrete interface (and would not be detectable without the trait) is=
in the proposal as the blocking property:<div><pre style=3D"color:rgb(0,0,=
0);font-style:normal;font-weight:400;letter-spacing:normal;text-align:start=
;text-indent:0px;text-transform:none;word-spacing:0px;word-wrap:break-word;=
white-space:pre-wrap">The `blocking_t` property describes what guarantees e=
xecutors provide about the blocking behavior of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|------------------------|--------------|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor=
's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an executor'=
;s execution function shall block until completion of all execution agents =
created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |</pre></div><div><br></div><div>Th=
is is a very important property because it is vitally important that I can =
push a continuation into an executor such a guarantee that it will not bloc=
k the caller. An inline executor would not satisfy that property, because i=
t would block until the function is complete. An executor with a logically =
infinite queue can guarantee that it is non-blocking, and should say so.</d=
iv><div><br></div><div>The execute function looks the same but I can use th=
at trait as a filter on what executor my library accepts.</div></div></bloc=
kquote><div><br></div></div><div dir=3D"ltr"><div>I see. It do be necessary=
for users.</div><div><br></div><div>By the way, I think maybe we could def=
ine the semantics of bulk execution like:=C2=A0</div><div><br></div><div><d=
iv class=3D"m_-8252313179381676017m_3189367164318302795m_-40884495402417214=
55prettyprint" style=3D"background-color:rgb(250,250,250);border-color:rgb(=
187,187,187);border-style:solid;border-width:1px;word-wrap:break-word"><cod=
e class=3D"m_-8252313179381676017m_3189367164318302795m_-408844954024172145=
5prettyprint"><div class=3D"m_-8252313179381676017m_3189367164318302795m_-4=
088449540241721455subprettyprint"><font color=3D"#660066"><div class=3D"m_-=
8252313179381676017m_3189367164318302795m_-4088449540241721455subprettyprin=
t">A type E meets the BulkOnewayExecutor requirements if the following expr=
essions are well-formed and have the specified semantics (e denotes a value=
of type E).</div><div class=3D"m_-8252313179381676017m_3189367164318302795=
m_-4088449540241721455subprettyprint"><br></div><div class=3D"m_-8252313179=
381676017m_3189367164318302795m_-4088449540241721455subprettyprint">e.bulk_=
execute(funcs)</div><div class=3D"m_-8252313179381676017m_31893671643183027=
95m_-4088449540241721455subprettyprint">=C2=A0 Requires: `funcs` shall be r=
andom accessable (funcs[i] represents a Callable type for each `i` of type =
`std::size_t` in range `[0, funcs.size())`), or otherwise be iterable (func=
s.begin(), funcs.end() shall be well-formed and have specific semantics...)=
..</div><div class=3D"m_-8252313179381676017m_3189367164318302795m_-40884495=
40241721455subprettyprint">=C2=A0 Effects: Perform `DECAY_COPY(funcs[i])()`=
for each `i` of type `std::size_t` in range `[0, funcs.size())` if `funcs`=
is random accessable, or perform `DECAY_COPY(f)()` for each `f` in the for=
-range loop `for (autp& f : funcs)`.</div></font></div></code></div><br=
>I think that would be more ease-to-use than `x.bulk_execute(f, n, sf)`. I =
am looking forward to your comments!</div></div></blockquote><div><br></div=
></span><div>Now I have to create a range of functions to be able to bulk e=
xecute, where previously I could just have a function and some context argu=
ments. This is way more complex to use than the current interface (even if =
you need a dummy `fs`).</div><div><br></div><div>Remember that executors ar=
e the low-level building blocks for more complex library facilities. The lo=
wlevelness of this API is perfectly fine. (I can imagine a lot of users of =
`bulk_execute` will return a tuple from `fs` and `std::apply` with it somew=
here in `f`. I <i>can't</i>=C2=A0imagine too many users using `bulk_exe=
cute` directly from an <i>application</i>. (If those assumptions are wrong,=
I will stand corrected - but that's what I understand the assumptions =
made by the paper to be.))</div><span><div>=C2=A0</div><blockquote class=3D=
"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc solid;padding=
-left:1ex">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-4911-9006-3198cc8db746%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/788b309c-d4b3-=
4911-9006-3198cc8db746%40isocpp.org</a>.<br>
</blockquote></span></div></div><span>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span></blockquot=
e></div></div><div class=3D"gmail_extra"><div class=3D"gmail_quote"><blockq=
uote class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc =
solid;padding-left:1ex">
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAPCFJdTF9JncZJvLSF4YJ4DsCX09A_dm7n9g=
UgEsD3f7W5TJRQ%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter"=
target=3D"_blank">https://groups.google.com/a/isocpp.org/d/msgid/std-propo=
sals/CAPCFJdTF9JncZJvLSF4YJ4DsCX09A_dm7n9gUgEsD3f7W5TJRQ%40mail.gmail.com</=
a>.<br>
</blockquote></div><br></div>
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAJH_FNU4cvBYek4XptAz7HDJZfuQaP8V3yEC=
Tv1qE5f5O%3DVGbA%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfoote=
r" target=3D"_blank">https://groups.google.com/a/isocpp.org/d/msgid/std-pro=
posals/CAJH_FNU4cvBYek4XptAz7HDJZfuQaP8V3yECTv1qE5f5O%3DVGbA%40mail.gmail.c=
om</a>.<br>
</blockquote></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAPCFJdT-9dcOJMEXDVhQTp42N2rTBGtW8ww_=
67OUvxu5iVHs%3DA%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAPCFJdT-9dcOJM=
EXDVhQTp42N2rTBGtW8ww_67OUvxu5iVHs%3DA%40mail.gmail.com</a>.<br />
--001a114dd4d03c1fab05691e445d--
.
Author: jaredhoberock@gmail.com
Date: Thu, 5 Apr 2018 12:12:00 -0700 (PDT)
Raw View
------=_Part_5588_40505770.1522955520713
Content-Type: multipart/alternative;
boundary="----=_Part_5589_911081682.1522955520714"
------=_Part_5589_911081682.1522955520714
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Thursday, April 5, 2018 at 12:56:10 PM UTC-5, Micha=C5=82 Dominiak wrote=
:
>
> On Thu, Apr 5, 2018 at 6:42 PM Mingxin Wang <wmx16...@163.com=20
> <javascript:>> wrote:
>
>> On Wednesday, April 4, 2018 at 4:50:10 AM UTC+8, Lee Howes wrote:
>>>
>>> A simple example of where properties do not change the concrete=20
>>> interface (and would not be detectable without the trait) is in the=20
>>> proposal as the blocking property:
>>>
>>> The `blocking_t` property describes what guarantees executors provide a=
bout the blocking behavior of their execution functions.
>>>
>>> `blocking_t` provides nested property types and objects as described be=
low.
>>>
>>> | Nested Property Type | Nested Property Object Name | Requirements |
>>> |--------------------------|------------------------|--------------|
>>> | `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an exec=
utor's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
>>> | `blocking_t::always_t` | `blocking_t::always` | A call to an executor=
's execution function shall block until completion of all execution agents =
created by that execution function. |
>>> | `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |
>>>
>>>
>>> This is a very important property because it is vitally important that =
I=20
>>> can push a continuation into an executor such a guarantee that it will =
not=20
>>> block the caller. An inline executor would not satisfy that property,=
=20
>>> because it would block until the function is complete. An executor with=
a=20
>>> logically infinite queue can guarantee that it is non-blocking, and sho=
uld=20
>>> say so.
>>>
>>> The execute function looks the same but I can use that trait as a filte=
r=20
>>> on what executor my library accepts.
>>>
>>
>> I see. It do be necessary for users.
>>
>> By the way, I think maybe we could define the semantics of bulk executio=
n=20
>> like:=20
>>
>> A type E meets the BulkOnewayExecutor requirements if the following=20
>> expressions are well-formed and have the specified semantics (e denotes =
a=20
>> value of type E).
>>
>> e.bulk_execute(funcs)
>> Requires: `funcs` shall be random accessable (funcs[i] represents a=20
>> Callable type for each `i` of type `std::size_t` in range `[0,=20
>> funcs.size())`), or otherwise be iterable (funcs.begin(), funcs.end() sh=
all=20
>> be well-formed and have specific semantics...).
>> Effects: Perform `DECAY_COPY(funcs[i])()` for each `i` of type=20
>> `std::size_t` in range `[0, funcs.size())` if `funcs` is random accessab=
le,=20
>> or perform `DECAY_COPY(f)()` for each `f` in the for-range loop `for (au=
tp&=20
>> f : funcs)`.
>>
>> I think that would be more ease-to-use than `x.bulk_execute(f, n, sf)`. =
I=20
>> am looking forward to your comments!
>>
>
> Now I have to create a range of functions to be able to bulk execute,=20
> where previously I could just have a function and some context arguments.=
=20
> This is way more complex to use than the current interface (even if you=
=20
> need a dummy `fs`).
>
> Remember that executors are the low-level building blocks for more comple=
x=20
> library facilities. The lowlevelness of this API is perfectly fine. (I ca=
n=20
> imagine a lot of users of `bulk_execute` will return a tuple from `fs` an=
d=20
> `std::apply` with it somewhere in `f`. I *can't* imagine too many users=
=20
> using `bulk_execute` directly from an *application*. (If those=20
> assumptions are wrong, I will stand corrected - but that's what I=20
> understand the assumptions made by the paper to be.))
>
This is exactly right. There will be more convenient ways to use bulk=20
executors rather than accessing their execution functions directly. For=20
example, once parallel algorithms are integrated with executors, for_each=
=20
and reduce will be much more convenient than using .bulk_twoway_execute().=
=20
Likewise with single executors, std::async(ex, f, args...) will be more=20
convenient than doing the equivalent through ex.execute().
When designing execution functions, I think it's fair to say that we have=
=20
prioritized the task of implementing executors and executor adaptors,=20
rather than the convenience of using execution functions directly. We will=
=20
have higher-level control structures to provide those conveniences.
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/d46115ea-c394-4739-9280-c3282fe5c63b%40isocpp.or=
g.
------=_Part_5589_911081682.1522955520714
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><br>On Thursday, April 5, 2018 at 12:56:10 PM UTC-5, M=
icha=C5=82 Dominiak wrote:<blockquote class=3D"gmail_quote" style=3D"margin=
: 0;margin-left: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div=
dir=3D"ltr"><div class=3D"gmail_quote"><div dir=3D"ltr">On Thu, Apr 5, 201=
8 at 6:42 PM Mingxin Wang <<a href=3D"javascript:" target=3D"_blank" gdf=
-obfuscated-mailto=3D"CeQjEp8vBgAJ" rel=3D"nofollow" onmousedown=3D"this.hr=
ef=3D'javascript:';return true;" onclick=3D"this.href=3D'javasc=
ript:';return true;">wmx16...@163.com</a>> wrote:<br></div><blockquo=
te class=3D"gmail_quote" style=3D"margin:0 0 0 .8ex;border-left:1px #ccc so=
lid;padding-left:1ex"><div dir=3D"ltr">On Wednesday, April 4, 2018 at 4:50:=
10 AM UTC+8, Lee Howes wrote:<blockquote class=3D"gmail_quote" style=3D"mar=
gin:0;margin-left:0.8ex;border-left:1px #ccc solid;padding-left:1ex"><div d=
ir=3D"ltr">A simple example of where properties do not change the concrete =
interface (and would not be detectable without the trait) is in the proposa=
l as the blocking property:<div><pre style=3D"color:rgb(0,0,0);font-style:n=
ormal;font-weight:400;letter-spacing:normal;text-align:start;text-indent:0p=
x;text-transform:none;word-spacing:0px;word-wrap:break-word;white-space:pre=
-wrap">The `blocking_t` property describes what guarantees executors provid=
e about the blocking behavior of their execution functions.
`blocking_t` provides nested property types and objects as described below.
| Nested Property Type | Nested Property Object Name | Requirements |
|--------------------------|--<wbr>----------------------|-------<wbr>-----=
--|
| `blocking_t::possibly_t` | `blocking_t::possibly` | A call to an executor=
's execution function may block pending completion of one or more of th=
e execution agents created by that execution function. |
| `blocking_t::always_t` | `blocking_t::always` | A call to an executor'=
;s execution function shall block until completion of all execution agents =
created by that execution function. |
| `blocking_t::never_t` | `blocking_t::never` | A call to an executor's=
execution function shall not block pending completion of the execution age=
nts created by that execution function. |</pre></div><div><br></div><div>Th=
is is a very important property because it is vitally important that I can =
push a continuation into an executor such a guarantee that it will not bloc=
k the caller. An inline executor would not satisfy that property, because i=
t would block until the function is complete. An executor with a logically =
infinite queue can guarantee that it is non-blocking, and should say so.</d=
iv><div><br></div><div>The execute function looks the same but I can use th=
at trait as a filter on what executor my library accepts.</div></div></bloc=
kquote><div><br></div></div><div dir=3D"ltr"><div>I see. It do be necessary=
for users.</div><div><br></div><div>By the way, I think maybe we could def=
ine the semantics of bulk execution like:=C2=A0</div><div><br></div><div><d=
iv style=3D"background-color:rgb(250,250,250);border-color:rgb(187,187,187)=
;border-style:solid;border-width:1px;word-wrap:break-word"><code><div><font=
color=3D"#660066"><div>A type E meets the BulkOnewayExecutor requirements =
if the following expressions are well-formed and have the specified semanti=
cs (e denotes a value of type E).</div><div><br></div><div>e.bulk_execute(f=
uncs)</div><div>=C2=A0 Requires: `funcs` shall be random accessable (funcs[=
i] represents a Callable type for each `i` of type `std::size_t` in range `=
[0, funcs.size())`), or otherwise be iterable (funcs.begin(), funcs.end() s=
hall be well-formed and have specific semantics...).</div><div>=C2=A0 Effec=
ts: Perform `DECAY_COPY(funcs[i])()` for each `i` of type `std::size_t` in =
range `[0, funcs.size())` if `funcs` is random accessable, or perform `DECA=
Y_COPY(f)()` for each `f` in the for-range loop `for (autp& f : funcs)`=
..</div></font></div></code></div><br>I think that would be more ease-to-use=
than `x.bulk_execute(f, n, sf)`. I am looking forward to your comments!</d=
iv></div></blockquote><div><br></div><div>Now I have to create a range of f=
unctions to be able to bulk execute, where previously I could just have a f=
unction and some context arguments. This is way more complex to use than th=
e current interface (even if you need a dummy `fs`).</div><div><br></div><d=
iv>Remember that executors are the low-level building blocks for more compl=
ex library facilities. The lowlevelness of this API is perfectly fine. (I c=
an imagine a lot of users of `bulk_execute` will return a tuple from `fs` a=
nd `std::apply` with it somewhere in `f`. I <i>can't</i>=C2=A0imagine t=
oo many users using `bulk_execute` directly from an <i>application</i>. (If=
those assumptions are wrong, I will stand corrected - but that's what =
I understand the assumptions made by the paper to be.))</div></div></div></=
blockquote><div><br></div><div>This is exactly right. There will be more co=
nvenient ways to use bulk executors rather than accessing their execution f=
unctions directly. For example, once parallel algorithms are integrated wit=
h executors, for_each and reduce will be much more convenient than using .b=
ulk_twoway_execute(). Likewise with single executors, std::async(ex, f, arg=
s...) will be more convenient than doing the equivalent through ex.execute(=
).</div><div><br></div><div>When designing execution functions, I think it&=
#39;s fair to say that we have prioritized the task of implementing executo=
rs and executor adaptors, rather than the convenience of using execution fu=
nctions directly. We will have higher-level control structures to provide t=
hose conveniences.</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/d46115ea-c394-4739-9280-c3282fe5c63b%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/d46115ea-c394-4739-9280-c3282fe5c63b=
%40isocpp.org</a>.<br />
------=_Part_5589_911081682.1522955520714--
------=_Part_5588_40505770.1522955520713--
.
Author: =?UTF-8?Q?Klaim_=2D_Jo=C3=ABl_Lamotte?= <mjklaim@gmail.com>
Date: Fri, 6 Apr 2018 00:14:45 +0200
Raw View
--000000000000cd499105692146b3
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On 5 April 2018 at 18:18, Mingxin Wang <wmx16835vv@163.com> wrote:
> On Thursday, April 5, 2018 at 7:12:46 AM UTC+8, Klaim - Jo=C3=ABl Lamotte=
wrote:
>>
>>
>> On 4 April 2018 at 19:17, Mingxin Wang <wmx16...@163.com> wrote:
>>
>>>
>>>> My understanding is totally different: work-stealing does the workload
>>>> balance for threads in more efficient way than simpler algorithms for
>>>> managing task queues.
>>>>
>>>
>>> What do you mean by "in a more efficient way"? Do you mean the "Half
>>> Sync/Half Async" pattern? I am not quite familiar with the implementati=
ons
>>> you mentioned, but in Java, the "Fork Join Pool" seems not have such
>>> feature.
>>>
>>>
>>
>> Efficient way as in it's making sure threads not having work will do the
>> work queued for threads not finished with their current executing work.
>> It's more like flattening work over execution resources, therefore havin=
g
>> a change to execute all the work in the most efficeint way (assuming the
>> works don't sync on common data).
>>
>
> Do you mean the situation where worker threads have their unique working
> queue? Actually, in my sample implementation above, there is only one
> working queue, and it is always "load-balanced" within a thread pool
> entity. I think it is not necessary to build working queues for each work=
er
> thread most of the time (except for some cases in hardware, which are not
> in the scope of our discussion), unless the frequency of task submission =
is
> so high that could become a bottleneck, the monitor pattern (mutexies and
> condition variables) will no longer feasible, and maybe we will need to
> find a new synchronization mechanism (maybe with much lower level
> primitives like the "futex" in POSIX). However, when there is no bottlene=
ck
> in task submission, I think there is no necessity to make the algorithm
> more complex, which may introduce other weakness in performance or
> extendibility.
>
>
It's too bad that you can't see sean parent's video, he debunks your
assumption.
It's, in general, faster to have data not shared between threads, no
contention by sharing one mutex with other threads and it's not even enough
to have good performance, in which case doing the work-stealing stuffs
helps.
> It have nothing to do with waiting, but it does have to do with the
>>>> unpredictable nature of execution time of varied kinds of work (so it'=
s
>>>> helful even when task implementors persist with waiting).
>>>> It works well in the case we don't know what tasks will be executed an=
d
>>>> when. This is why most general-purpose thread-pools are using some var=
iant
>>>> of work-stealing (as showed in the talk video).
>>>>
>>>
>>> As far as I am concerned, work-stealing is about "executing irrelevant
>>> work while waiting". In the "Fork Join Pool" in Java, a task should alw=
ays
>>> wait for a forked task to be done with a specific API to work. The
>>> implementation registers the waiting thread to a internal data structur=
e,
>>> and assigns tasks if available, resulting in possible delay for the wai=
ting
>>> operation to unblock. All these works produce overhead.
>>>
>>>
>> I don't know what "Fork Join Pool" is in Java but just by the name it
>> looks like some kind of map/reduce algorithm? If yes, I think you might =
be
>> mixing how a thread pool manage workload (work-stealing)
>> and how to generate and manage work to be dispatched in (one or several)
>> executors (that might or might not be a thread pool) - (also see
>> std::reduce algorithm, bulk_execute examples in the design document for
>> executors and
>> Task Blocks in N4725).
>> If no, then I don't understand what you are talking about, sorry. ^^;
>>
>
> In simple terms, the "Fork Join Pool" in Java (aka. `class ForkJoinPool`
> [1]) is a framework [2] that provides a pattern to "join" subtasks with
> "work stealing" strategy. That is, stealing tasks from the depended threa=
d
> pool while waiting.
>
>
I believe this is not the same work-stealing then, or not applied at the
same abstraction level (it seems "over" the thread pool).
> However, if we use `async_concurrent_invoke` proposed in P0642, there
>>> won't be any blocking at all, and there will be little necessity to use
>>> "work-stealing" strategy. As asynchronous programming will make it more
>>> complex to manage resources, especially execution agents, so a
>>> "synchronous" version is also provided as `sync_concurrent_invoke`, whe=
re
>>> one could specify custom blocking algorithm, including the "work-steali=
ng"
>>> if necessary. There is a more detailed analysis in P0642.
>>>
>>>
>> I don't see the relationship between work-stealing (which is an
>> implementation detail of how tasks are distributed through available
>> threads) and the rest of your points. Maybe I'm misunderstanding somethi=
ng.
>>
>>
>>> Honestly, I have not read the code of the facilities you mentioned, and
>>> I am not sure whether they have different mechanism to the "Fork Join P=
ool"
>>> in Java. If so, could you provide any related code or document? Thank y=
ou.
>>>
>>>
>> The simplest code I could show you is the one in Sean Parent's talk,
>> which is simple enough to be quickly understood.
>>
>
> I am sorry that I am not able to watch the video on youtube (I am from
> China, and the network speed is not enough to load the video from youtube
> (=EF=BC=9E=EF=B9=8F=EF=BC=9C) ). Could you provide a snapshot or a copy o=
f the code? Thank you!
>
>
I understand.
Here are Sean Parent papers and presentations, with the slides:
http://sean-parent.stlab.cc/papers-and-presentations/
I recommand them all.
The one we are talking about is there:
http://sean-parent.stlab.cc/papers-and-presentations/#better-code-concurren=
cy
In particular these slides:
http://sean-parent.stlab.cc/presentations/2017-01-18-concurrency/2017-01-18=
-concurrency.pdf
The thread-pool part starts at slide 28.
He progressively implements a general thread pool and measure it's
performance against Apple=E2=80=99s Grand Central Dispatch (which is the th=
read
pool provided by OSX).
The implementation is available on github:
https://github.com/stlab/libraries/tree/develop/stlab/concurrency (it might
have evolved since the slides).
Unfortunately having the video would be best because the comments are
helpful to understand most of the slides.
I will try to put the video somewhere but I can't garantee anything
unfortunately.
Jo=C3=ABl Lamotte
> [1] Java SE API, https://docs.oracle.com/javase/10/docs/api/java/util/
> concurrent/ForkJoinPool.html.
> [2] Lea, Doug. "A Java fork/join framework." *Proceedings of the ACM 2000
> conference on Java Grande*. ACM, 2000.
>
> --
> You received this message because you are subscribed to the Google Groups
> "ISO C++ Standard - Future Proposals" group.
> To unsubscribe from this group and stop receiving emails from it, send an
> email to std-proposals+unsubscribe@isocpp.org.
> To post to this group, send email to std-proposals@isocpp.org.
> To view this discussion on the web visit https://groups.google.com/a/
> isocpp.org/d/msgid/std-proposals/8547ebde-b1f1-41ca-
> 9454-69e6dfe974a6%40isocpp.org
> <https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/8547ebde-b1=
f1-41ca-9454-69e6dfe974a6%40isocpp.org?utm_medium=3Demail&utm_source=3Dfoot=
er>
> .
>
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/CAOU91OPFHYFsrNPRTkjTiOqwaJMPGFrw7cnto5%2BcsprW3=
rsOeQ%40mail.gmail.com.
--000000000000cd499105692146b3
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr"><br><div class=3D"gmail_extra"><br><div class=3D"gmail_quo=
te">On 5 April 2018 at 18:18, Mingxin Wang <span dir=3D"ltr"><<a href=3D=
"mailto:wmx16835vv@163.com" target=3D"_blank">wmx16835vv@163.com</a>></s=
pan> wrote:<br><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0p=
x 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=
=3D"ltr">On Thursday, April 5, 2018 at 7:12:46 AM UTC+8, Klaim - Jo=C3=ABl =
Lamotte wrote:<span class=3D"gmail-"><blockquote class=3D"gmail_quote" styl=
e=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);paddin=
g-left:1ex"><div dir=3D"ltr"><div><br><div class=3D"gmail_quote">On 4 April=
2018 at 19:17, Mingxin Wang <span dir=3D"ltr"><<a rel=3D"nofollow">wmx1=
6...@163.com</a>></span> wrote:<br><blockquote class=3D"gmail_quote" sty=
le=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);paddi=
ng-left:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" style=
=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding=
-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div><br></div><div>=
My understanding is totally different: work-stealing does the workload bala=
nce for threads in more efficient way than simpler algorithms for managing =
task queues.</div></div></div></blockquote><div><br></div></span><div>What =
do you mean by "in a more efficient way"? Do you mean the "H=
alf Sync/Half Async" pattern? I am not quite familiar with the impleme=
ntations you mentioned, but in Java, the "Fork Join Pool" seems n=
ot have such feature.</div><span><div>=C2=A0</div></span></div></blockquote=
><div><br></div><div>Efficient way as in it's making sure threads not h=
aving work will do the work queued for threads not finished with their curr=
ent executing work.</div><div>It's more like flattening work over execu=
tion resources, therefore having a change to execute all the work in the mo=
st efficeint way (assuming the works don't sync on common data).</div><=
/div></div></div></blockquote><div><br></div></span><div>Do you mean the si=
tuation where worker threads have their unique working queue? Actually, in =
my sample implementation above, there is only one working queue, and it is =
always "load-balanced" within a thread pool entity. I think it is=
not necessary to build working queues for each worker thread most of the t=
ime (except for some cases in hardware, which are not in the scope of our d=
iscussion), unless the frequency of task submission is so high that could b=
ecome a bottleneck, the monitor pattern (mutexies and condition variables) =
will no longer feasible, and maybe we will need to find a new synchronizati=
on mechanism (maybe with much lower level primitives like the "futex&q=
uot; in POSIX). However, when there is no bottleneck in task submission, I =
think there is no necessity to make the algorithm more complex, which may i=
ntroduce other weakness in performance or extendibility.</div><span class=
=3D"gmail-"><div>=C2=A0</div></span></div></blockquote><div><br></div><div>=
It's too bad that you can't see sean parent's video, he debunks=
your assumption.</div><div>It's, in general, faster to have data not s=
hared between threads, no contention by sharing one mutex with other thread=
s and it's not even enough to have good performance, in which case doin=
g the work-stealing stuffs helps.</div><div><br></div><div>=C2=A0</div><blo=
ckquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left=
:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><span class=
=3D"gmail-"><blockquote class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0=
..8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div dir=3D"l=
tr"><div class=3D"gmail_quote"><blockquote class=3D"gmail_quote" style=3D"m=
argin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left=
:1ex"><div dir=3D"ltr"><span><blockquote class=3D"gmail_quote" style=3D"mar=
gin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1=
ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><div>It have nothing to do =
with waiting, but it does have to do with the</div><div>unpredictable natur=
e of execution time of varied kinds of work (so it's helful even when t=
ask implementors persist with waiting).</div><div>It works well in the case=
we don't know what tasks will be executed and when. This is why most g=
eneral-purpose thread-pools are using some variant of work-stealing (as sho=
wed in the talk video).</div></div></div></blockquote><div><br></div></span=
><div>As far as I am concerned, work-stealing is about "executing irre=
levant work while waiting". In the "Fork Join Pool" in Java,=
a task should always wait for a forked task to be done with a specific API=
to work. The implementation registers the waiting thread to a internal dat=
a structure, and assigns tasks if available, resulting in possible delay fo=
r the waiting operation to unblock. All these works produce overhead.<br></=
div><div><br></div></div></blockquote><div><br></div><div>I don't know =
what "Fork Join Pool" is in Java but just by the name it looks li=
ke some kind of map/reduce algorithm? If yes, I think you might be mixing h=
ow a thread pool manage workload (work-stealing)</div><div>and how to gener=
ate and manage work to be dispatched in (one or several) executors (that mi=
ght or might not be a thread pool) - (also see std::reduce algorithm,=C2=A0=
bulk_execute examples in the design document for executors and=C2=A0</div><=
div>Task Blocks in=C2=A0N4725).</div><div>If no, then I don't understan=
d what you are talking about, sorry. ^^;</div></div></div></blockquote><div=
><br></div></span><div>In simple terms, the "Fork Join Pool" in J=
ava (aka. `class ForkJoinPool` [1]) is a framework [2] that provides a patt=
ern to "join" subtasks with "work stealing" strategy. T=
hat is, stealing tasks from the depended thread pool while waiting.</div><s=
pan class=3D"gmail-"><div><br></div></span></div></blockquote><div><br></di=
v><div>I believe this is not the same work-stealing then, or not applied at=
the same abstraction level (it seems "over" the thread pool).</d=
iv><div>=C2=A0</div><blockquote class=3D"gmail_quote" style=3D"margin:0px 0=
px 0px 0.8ex;border-left:1px solid rgb(204,204,204);padding-left:1ex"><div =
dir=3D"ltr"><span class=3D"gmail-"><div></div><blockquote class=3D"gmail_qu=
ote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,204,20=
4);padding-left:1ex"><div dir=3D"ltr"><div class=3D"gmail_quote"><blockquot=
e class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px s=
olid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>Ho=
wever, if we use `async_concurrent_invoke` proposed in P0642, there won'=
;t be any blocking at all, and there will be little necessity to use "=
work-stealing" strategy. As asynchronous programming will make it more=
complex to manage resources, especially execution agents, so a "synch=
ronous" version is also provided as `sync_concurrent_invoke`, where on=
e could specify custom blocking algorithm, including the "work-stealin=
g" if necessary. There is a more detailed analysis in P0642.</div><div=
><br></div></div></blockquote><div><br></div><div>I don't see the relat=
ionship between work-stealing (which is an implementation detail of how tas=
ks are distributed through available threads) and the rest of your points. =
Maybe I'm misunderstanding something.</div><div>=C2=A0</div><blockquote=
class=3D"gmail_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px so=
lid rgb(204,204,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>Hon=
estly, I have not read the code of the facilities you mentioned, and I am n=
ot sure whether they have different mechanism to the "Fork Join Pool&q=
uot; in Java. If so, could you provide any related code or document? Thank =
you.</div><span><div><br></div></span></div></blockquote><div><br></div><di=
v>The simplest code I could show you is the one in Sean Parent's talk, =
which is simple enough to be quickly understood.</div></div></div></blockqu=
ote><div><br></div></span><div>I am sorry that I am not able to watch the v=
ideo on youtube (I am from China, and the network speed is not enough to lo=
ad the video from youtube (=EF=BC=9E=EF=B9=8F=EF=BC=9C)=C2=A0). Could you p=
rovide a snapshot or a copy of the code? Thank you!</div><div><br></div></d=
iv></blockquote><div><br></div><div>I understand.</div><div><br></div><div>=
Here are Sean Parent papers and presentations, with the slides:=C2=A0<a hre=
f=3D"http://sean-parent.stlab.cc/papers-and-presentations/">http://sean-par=
ent.stlab.cc/papers-and-presentations/</a></div><div>I recommand them all.<=
/div><div>The one we are talking about is there:=C2=A0<a href=3D"http://sea=
n-parent.stlab.cc/papers-and-presentations/#better-code-concurrency">http:/=
/sean-parent.stlab.cc/papers-and-presentations/#better-code-concurrency</a>=
</div><div>In particular these slides:=C2=A0<a href=3D"http://sean-parent.s=
tlab.cc/presentations/2017-01-18-concurrency/2017-01-18-concurrency.pdf">ht=
tp://sean-parent.stlab.cc/presentations/2017-01-18-concurrency/2017-01-18-c=
oncurrency.pdf</a></div><div>The thread-pool part starts at slide 28.</div>=
<div>He progressively implements a general thread pool and measure it's=
performance against Apple=E2=80=99s Grand Central Dispatch (which is the t=
hread pool provided by OSX).</div><div>The implementation is available on g=
ithub:=C2=A0<a href=3D"https://github.com/stlab/libraries/tree/develop/stla=
b/concurrency">https://github.com/stlab/libraries/tree/develop/stlab/concur=
rency</a> (it might have evolved since the slides).</div><div><br></div><di=
v>Unfortunately having the video would be best because the comments are hel=
pful to understand most of the slides.</div><div>I will try to put the vide=
o somewhere but I can't garantee anything unfortunately.</div><div><br>=
</div><div>Jo=C3=ABl Lamotte</div><div>=C2=A0</div><blockquote class=3D"gma=
il_quote" style=3D"margin:0px 0px 0px 0.8ex;border-left:1px solid rgb(204,2=
04,204);padding-left:1ex"><div dir=3D"ltr"><div></div><div>[1] Java SE API,=
=C2=A0<a href=3D"https://docs.oracle.com/javase/10/docs/api/java/util/concu=
rrent/ForkJoinPool.html" target=3D"_blank">https://docs.oracle.com/<wbr>jav=
ase/10/docs/api/java/util/<wbr>concurrent/ForkJoinPool.html</a>.</div><div>=
[2]=C2=A0<span style=3D"font-family:Arial,sans-serif">Lea, Doug. "A Ja=
va fork/join framework."=C2=A0</span><i style=3D"font-family:Arial,san=
s-serif">Proceedings of the ACM 2000 conference on Java Grande</i><span sty=
le=3D"font-family:Arial,sans-serif">. ACM, 2000.</span>=C2=A0</div></div><s=
pan class=3D"gmail-">
<p></p>
-- <br>
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br>
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org" target=3D"_=
blank">std-proposals+unsubscribe@<wbr>isocpp.org</a>.<br>
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org" target=3D"_blank">std-proposals@isocpp.org</a>.<br></span>
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/8547ebde-b1f1-41ca-9454-69e6dfe974a6%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter" target=3D"_blank">=
https://groups.google.com/a/<wbr>isocpp.org/d/msgid/std-<wbr>proposals/8547=
ebde-b1f1-41ca-<wbr>9454-69e6dfe974a6%40isocpp.org</a><wbr>.<br>
</blockquote></div><br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/CAOU91OPFHYFsrNPRTkjTiOqwaJMPGFrw7cnt=
o5%2BcsprW3rsOeQ%40mail.gmail.com?utm_medium=3Demail&utm_source=3Dfooter">h=
ttps://groups.google.com/a/isocpp.org/d/msgid/std-proposals/CAOU91OPFHYFsrN=
PRTkjTiOqwaJMPGFrw7cnto5%2BcsprW3rsOeQ%40mail.gmail.com</a>.<br />
--000000000000cd499105692146b3--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Fri, 6 Apr 2018 23:21:20 -0700 (PDT)
Raw View
------=_Part_12193_152702146.1523082080553
Content-Type: multipart/alternative;
boundary="----=_Part_12194_1769951805.1523082080553"
------=_Part_12194_1769951805.1523082080553
Content-Type: text/plain; charset="UTF-8"
On Friday, April 6, 2018 at 2:25:57 AM UTC+8, Lee Howes wrote:
>
> Worse than that, unless we had some way to prove that every function in
> the list was identically, compiled to the same token sequence and could be
> effectively merged, we might as well not have bulk_execute at all because
> it wouldn't work for the intended use cases.
>
Are the "intended use cases" referring to the "2-D" GPU related cases in
the previous posts? From my point of view, it might not be general enough
since the GPUs usually have different memory model from C++. Meanwhile, a
solution with the complexity of O(square root of N) seems not optimal, as
it could be reduced to O(log(N)) if there is a "random access" promise.
--
You received this message because you are subscribed to the Google Groups "ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an email to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp.org/d/msgid/std-proposals/7681de80-8eab-43d6-9e17-ffa6ed1a3ec6%40isocpp.org.
------=_Part_12194_1769951805.1523082080553
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Friday, April 6, 2018 at 2:25:57 AM UTC+8, Lee Howes wr=
ote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-left: 0.8ex=
;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr">Worse tha=
n that, unless we had some way to prove that every function in the list was=
identically, compiled to the same token sequence and could be effectively =
merged, we might as well not have bulk_execute at all because it wouldn'=
;t work for the intended use cases.</div></blockquote><div><br></div><div>A=
re the "intended use cases" referring to the "2-D" GPU =
related cases in the previous posts? From my point of view, it might not be=
general enough since the GPUs usually have different memory model from C++=
.. Meanwhile, a solution with the complexity of O(square root of N) seems no=
t optimal, as it could be reduced to O(log(N)) if there is a "random a=
ccess" promise.<br></div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/7681de80-8eab-43d6-9e17-ffa6ed1a3ec6%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/7681de80-8eab-43d6-9e17-ffa6ed1a3ec6=
%40isocpp.org</a>.<br />
------=_Part_12194_1769951805.1523082080553--
------=_Part_12193_152702146.1523082080553--
.
Author: Mingxin Wang <wmx16835vv@163.com>
Date: Fri, 6 Apr 2018 23:21:25 -0700 (PDT)
Raw View
------=_Part_11991_1711077312.1523082085110
Content-Type: multipart/alternative;
boundary="----=_Part_11992_394819494.1523082085110"
------=_Part_11992_394819494.1523082085110
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
On Friday, April 6, 2018 at 3:12:00 AM UTC+8, jaredh...@gmail.com wrote:
>
> On Thursday, April 5, 2018 at 12:56:10 PM UTC-5, Micha=C5=82 Dominiak wro=
te:
>>
>> Now I have to create a range of functions to be able to bulk execute,=20
>> where previously I could just have a function and some context arguments=
..=20
>> This is way more complex to use than the current interface (even if you=
=20
>> need a dummy `fs`).
>>
>> Remember that executors are the low-level building blocks for more=20
>> complex library facilities. The lowlevelness of this API is perfectly fi=
ne.=20
>> (I can imagine a lot of users of `bulk_execute` will return a tuple from=
=20
>> `fs` and `std::apply` with it somewhere in `f`. I *can't* imagine too=20
>> many users using `bulk_execute` directly from an *application*. (If=20
>> those assumptions are wrong, I will stand corrected - but that's what I=
=20
>> understand the assumptions made by the paper to be.))
>>
>
> This is exactly right. There will be more convenient ways to use bulk=20
> executors rather than accessing their execution functions directly. For=
=20
> example, once parallel algorithms are integrated with executors, for_each=
=20
> and reduce will be much more convenient than using .bulk_twoway_execute()=
..=20
> Likewise with single executors, std::async(ex, f, args...) will be more=
=20
> convenient than doing the equivalent through ex.execute().
>
> When designing execution functions, I think it's fair to say that we have=
=20
> prioritized the task of implementing executors and executor adaptors,=20
> rather than the convenience of using execution functions directly. We wil=
l=20
> have higher-level control structures to provide those conveniences.
>
I agree that "we have prioritized the task of implementing executors and=20
executor adaptors, rather than the convenience of using execution functions=
=20
directly", and there are a lot of situations where the "performance" is=20
more important than "usability". However, I think a solution is usually=20
more optimal than an existing one if it provides more usability while=20
carries no reduction on performance or extendability.
From another perspective, I think the motivation of the "TwoWay"=20
requirements could also be regarded as "usability", because we could easily=
=20
build a "two-way adapter" over any "one-way" executors. If, according to=20
your philosophy, users are not likely to use the API "directly from an=20
*application*", what is the significance of the existence of the "TwoWay"=
=20
requirements, as there are "higher-level control structures".
--=20
You received this message because you are subscribed to the Google Groups "=
ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
To view this discussion on the web visit https://groups.google.com/a/isocpp=
..org/d/msgid/std-proposals/fbfa8115-e748-405a-92c6-ac8f977eddb1%40isocpp.or=
g.
------=_Part_11992_394819494.1523082085110
Content-Type: text/html; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
<div dir=3D"ltr">On Friday, April 6, 2018 at 3:12:00 AM UTC+8, jaredh...@gm=
ail.com wrote:<blockquote class=3D"gmail_quote" style=3D"margin: 0;margin-l=
eft: 0.8ex;border-left: 1px #ccc solid;padding-left: 1ex;"><div dir=3D"ltr"=
>On Thursday, April 5, 2018 at 12:56:10 PM UTC-5, Micha=C5=82 Dominiak wrot=
e:<blockquote class=3D"gmail_quote" style=3D"margin:0;margin-left:0.8ex;bor=
der-left:1px #ccc solid;padding-left:1ex"><div dir=3D"ltr"><div class=3D"gm=
ail_quote"><div>Now I have to create a range of functions to be able to bul=
k execute, where previously I could just have a function and some context a=
rguments. This is way more complex to use than the current interface (even =
if you need a dummy `fs`).</div><div><br></div><div>Remember that executors=
are the low-level building blocks for more complex library facilities. The=
lowlevelness of this API is perfectly fine. (I can imagine a lot of users =
of `bulk_execute` will return a tuple from `fs` and `std::apply` with it so=
mewhere in `f`. I <i>can't</i>=C2=A0imagine too many users using `bulk_=
execute` directly from an <i>application</i>. (If those assumptions are wro=
ng, I will stand corrected - but that's what I understand the assumptio=
ns made by the paper to be.))</div></div></div></blockquote><div><br></div>=
<div>This is exactly right. There will be more convenient ways to use bulk =
executors rather than accessing their execution functions directly. For exa=
mple, once parallel algorithms are integrated with executors, for_each and =
reduce will be much more convenient than using .bulk_twoway_execute(). Like=
wise with single executors, std::async(ex, f, args...) will be more conveni=
ent than doing the equivalent through ex.execute().</div><div><br></div><di=
v>When designing execution functions, I think it's fair to say that we =
have prioritized the task of implementing executors and executor adaptors, =
rather than the convenience of using execution functions directly. We will =
have higher-level control structures to provide those conveniences.</div></=
div></blockquote><div><br></div><div>I agree that "we have prioritized=
the task of implementing executors and executor adaptors, rather than the =
convenience of using execution functions directly", and there are a lo=
t of situations where the "performance" is more important than &q=
uot;usability". However, I think a solution is usually more optimal th=
an an existing one if it provides more usability while carries no=C2=A0redu=
ction on performance or extendability.</div><div><br></div><div>From anothe=
r perspective, I think the motivation of the "TwoWay" requirement=
s could also be regarded as "usability", because we could easily =
build a "two-way adapter" over any "one-way" executors.=
If, according to your=C2=A0philosophy, users are not likely to use the API=
"directly from an=C2=A0<i>application</i>", what is the signific=
ance of the existence of the "TwoWay" requirements, as there are =
"higher-level control structures".</div></div>
<p></p>
-- <br />
You received this message because you are subscribed to the Google Groups &=
quot;ISO C++ Standard - Future Proposals" group.<br />
To unsubscribe from this group and stop receiving emails from it, send an e=
mail to <a href=3D"mailto:std-proposals+unsubscribe@isocpp.org">std-proposa=
ls+unsubscribe@isocpp.org</a>.<br />
To post to this group, send email to <a href=3D"mailto:std-proposals@isocpp=
..org">std-proposals@isocpp.org</a>.<br />
To view this discussion on the web visit <a href=3D"https://groups.google.c=
om/a/isocpp.org/d/msgid/std-proposals/fbfa8115-e748-405a-92c6-ac8f977eddb1%=
40isocpp.org?utm_medium=3Demail&utm_source=3Dfooter">https://groups.google.=
com/a/isocpp.org/d/msgid/std-proposals/fbfa8115-e748-405a-92c6-ac8f977eddb1=
%40isocpp.org</a>.<br />
------=_Part_11992_394819494.1523082085110--
------=_Part_11991_1711077312.1523082085110--
.