Commit 92dd0f71 authored by Amol Bhave's avatar Amol Bhave Committed by Facebook Github Bot

create unorderedReduceSemiFuture method

Summary:
create a unorderedReduceSemiFuture method that returns a SemiFuture
instead of just a Future.

Reviewed By: LeeHowes

Differential Revision: D16946582

fbshipit-source-id: e28b4cb055b3a9c67adebb373c60a775f7005762
parent e01c5188
...@@ -1090,26 +1090,25 @@ Future<T>::thenError(tag_t<ExceptionType>, F&& func) && { ...@@ -1090,26 +1090,25 @@ Future<T>::thenError(tag_t<ExceptionType>, F&& func) && {
auto* ePtr = this->getExecutor(); auto* ePtr = this->getExecutor();
auto e = folly::getKeepAliveToken(ePtr ? *ePtr : InlineExecutor::instance()); auto e = folly::getKeepAliveToken(ePtr ? *ePtr : InlineExecutor::instance());
this->setCallback_( this->setCallback_([state = futures::detail::makeCoreCallbackState(
[state = futures::detail::makeCoreCallbackState( std::move(p), std::forward<F>(func))](
std::move(p), std::forward<F>(func))]( Executor::KeepAlive<>&& ka, Try<T>&& t) mutable {
Executor::KeepAlive<>&& ka, Try<T>&& t) mutable { if (auto ex = t.template tryGetExceptionObject<
if (auto ex = t.template tryGetExceptionObject< std::remove_reference_t<ExceptionType>>()) {
std::remove_reference_t<ExceptionType>>()) { auto tf2 = state.tryInvoke(std::move(*ex));
auto tf2 = state.tryInvoke(std::move(*ex)); if (tf2.hasException()) {
if (tf2.hasException()) { state.setException(std::move(ka), std::move(tf2.exception()));
state.setException(std::move(ka), std::move(tf2.exception())); } else {
} else { tf2->setCallback_(
tf2->setCallback_( [p = state.stealPromise()](
[p = state.stealPromise()]( Executor::KeepAlive<>&& innerKA, Try<T>&& t3) mutable {
Executor::KeepAlive<>&& innerKA, Try<T>&& t3) mutable { p.setTry(std::move(innerKA), std::move(t3));
p.setTry(std::move(innerKA), std::move(t3)); });
}); }
} } else {
} else { state.setTry(std::move(ka), std::move(t));
state.setTry(std::move(ka), std::move(t)); }
} });
});
return std::move(sf).via(std::move(e)); return std::move(sf).via(std::move(e));
} }
...@@ -1872,9 +1871,8 @@ Future<I> Future<T>::reduce(I&& initial, F&& func) && { ...@@ -1872,9 +1871,8 @@ Future<I> Future<T>::reduce(I&& initial, F&& func) && {
// unorderedReduce (iterator) // unorderedReduce (iterator)
// TODO(T26439406): Make return SemiFuture
template <class It, class T, class F> template <class It, class T, class F>
Future<T> unorderedReduce(It first, It last, T initial, F func) { SemiFuture<T> unorderedReduceSemiFuture(It first, It last, T initial, F func) {
using ItF = typename std::iterator_traits<It>::value_type; using ItF = typename std::iterator_traits<It>::value_type;
using ItT = typename ItF::value_type; using ItT = typename ItF::value_type;
using Arg = MaybeTryArg<F, T, ItT>; using Arg = MaybeTryArg<F, T, ItT>;
...@@ -1914,6 +1912,9 @@ Future<T> unorderedReduce(It first, It last, T initial, F func) { ...@@ -1914,6 +1912,9 @@ Future<T> unorderedReduce(It first, It last, T initial, F func) {
} }
}; };
std::vector<futures::detail::DeferredWrapper> executors;
futures::detail::stealDeferredExecutors(executors, first, last);
auto ctx = std::make_shared<Context>( auto ctx = std::make_shared<Context>(
std::move(initial), std::move(func), std::distance(first, last)); std::move(initial), std::move(func), std::distance(first, last));
for (size_t i = 0; first != last; ++first, ++i) { for (size_t i = 0; first != last; ++first, ++i) {
...@@ -1936,28 +1937,44 @@ Future<T> unorderedReduce(It first, It last, T initial, F func) { ...@@ -1936,28 +1937,44 @@ Future<T> unorderedReduce(It first, It last, T initial, F func) {
}); });
} }
} }
f.setCallback_( f.setCallback_([ctx, mp = std::move(p), mt = std::move(t)](
[ctx, mp = std::move(p), mt = std::move(t)]( Executor::KeepAlive<>&&, Try<T>&& v) mutable {
Executor::KeepAlive<>&&, Try<T>&& v) mutable { if (v.hasValue()) {
if (v.hasValue()) { try {
try { Fulfill{}(
Fulfill{}( std::move(mp),
std::move(mp), ctx->func_(
ctx->func_( std::move(v.value()),
std::move(v.value()), mt.template get<IsTry::value, Arg&&>()));
mt.template get<IsTry::value, Arg&&>())); } catch (std::exception& e) {
} catch (std::exception& e) { mp.setException(exception_wrapper(std::current_exception(), e));
mp.setException(exception_wrapper(std::current_exception(), e)); } catch (...) {
} catch (...) { mp.setException(exception_wrapper(std::current_exception()));
mp.setException(exception_wrapper(std::current_exception())); }
} } else {
} else { mp.setTry(std::move(v));
mp.setTry(std::move(v)); }
} });
});
}); });
} }
return ctx->promise_.getSemiFuture().via(&InlineExecutor::instance());
auto future = ctx->promise_.getSemiFuture();
if (!executors.empty()) {
future = std::move(future).defer(
[](Try<typename decltype(future)::value_type>&& t) {
return std::move(t).value();
});
const auto& deferredExecutor = futures::detail::getDeferredExecutor(future);
deferredExecutor->setNestedExecutors(std::move(executors));
}
return future;
}
template <class It, class T, class F>
Future<T> unorderedReduce(It first, It last, T initial, F func) {
return unorderedReduceSemiFuture(
first, last, std::move(initial), std::move(func))
.via(&InlineExecutor::instance());
} }
// within // within
......
...@@ -139,26 +139,66 @@ TEST(Reduce, unorderedReduce) { ...@@ -139,26 +139,66 @@ TEST(Reduce, unorderedReduce) {
p1.setValue(1); p1.setValue(1);
EXPECT_EQ(1.0, std::move(f).get()); EXPECT_EQ(1.0, std::move(f).get());
} }
{
Promise<int> p1;
Promise<int> p2;
Promise<int> p3;
std::vector<SemiFuture<int>> fs;
fs.push_back(p1.getSemiFuture());
fs.push_back(p2.getSemiFuture());
fs.push_back(p3.getSemiFuture());
SemiFuture<double> f = unorderedReduceSemiFuture(
fs.begin(), fs.end(), 0.0, [](double /* a */, int&& b) {
return double(b);
});
p3.setValue(3);
p2.setValue(2);
p1.setValue(1);
EXPECT_EQ(1.0, std::move(f).get());
}
} }
TEST(Reduce, unorderedReduceException) { TEST(Reduce, unorderedReduceException) {
Promise<int> p1; {
Promise<int> p2; Promise<int> p1;
Promise<int> p3; Promise<int> p2;
Promise<int> p3;
std::vector<Future<int>> fs; std::vector<Future<int>> fs;
fs.push_back(p1.getFuture()); fs.push_back(p1.getFuture());
fs.push_back(p2.getFuture()); fs.push_back(p2.getFuture());
fs.push_back(p3.getFuture()); fs.push_back(p3.getFuture());
Future<double> f = Future<double> f =
unorderedReduce(fs.begin(), fs.end(), 0.0, [](double /* a */, int&& b) { unorderedReduce(fs.begin(), fs.end(), 0.0, [](double /* a */, int&& b) {
return b + 0.0; return b + 0.0;
}); });
p3.setValue(3); p3.setValue(3);
p2.setException(exception_wrapper(std::runtime_error("blah"))); p2.setException(exception_wrapper(std::runtime_error("blah")));
p1.setValue(1); p1.setValue(1);
EXPECT_THROW(std::move(f).get(), std::runtime_error); EXPECT_THROW(std::move(f).get(), std::runtime_error);
}
{
Promise<int> p1;
Promise<int> p2;
Promise<int> p3;
std::vector<SemiFuture<int>> fs;
fs.push_back(p1.getSemiFuture());
fs.push_back(p2.getSemiFuture());
fs.push_back(p3.getSemiFuture());
SemiFuture<double> f = unorderedReduceSemiFuture(
fs.begin(), fs.end(), 0.0, [](double /* a */, int&& b) {
return b + 0.0;
});
p3.setValue(3);
p2.setException(exception_wrapper(std::runtime_error("blah")));
p1.setValue(1);
EXPECT_THROW(std::move(f).get(), std::runtime_error);
}
} }
TEST(Reduce, unorderedReduceFuture) { TEST(Reduce, unorderedReduceFuture) {
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment