使用 std::future 和 std::async 的依赖项求解器
Dependency solver using std::future and std::async
我正在尝试使用 std::future
和 std::async
实现一个简单的依赖关系求解器。目前我不明白是否有可能做到这一点。问题是,我们可以将(尚不可用)future
传递给 async
调用吗?如果没有,实际上可以做些什么来让一些 尚未准备好 输入相互调用的函数链?也许,可以覆盖传递给延迟异步的值?
可能是我的描述看不懂,举个例子:
#include <iostream>
#include <future>
#include <map>
using namespace std;
int adder(future<int> a, future<int> b) {
return a.get() + b.get();
}
int main() {
map<char, future<int>> scheme;
scheme['c'] = future<int>(async(launch::deferred, [] { return 1;}));
scheme['a'] = future<int>(async(launch::deferred, adder, move(scheme['b']), move(scheme['c'])));
scheme['b'] = future<int>(async(launch::deferred, [] { return 3;}));
cout << scheme['a'].get() << endl;
}
我们应该有这样的方案:
c
\
a ----- result
/
b
以及 4
的结果。
此代码失败:move
只接受一个空的 future
并将其传递给 adder
。如果我们用 'a'
和 'b'
交换行,它会工作正常,但这样我们应该已经知道依赖关系了。
使用承诺。也许未来的未来。
template<class T>
struct problem {
std::promise<std::shared_future<T>> p;
std::shared_future<std::shared_future<T>> f;
problem():f(p.get_future()){}
template<class W, class...Args>
void set(W&&work, Args&&...args){
p.set_value(std::async(std::launch::deferred, std::forward<W>(work), std::forward<Args>(args)...));
}
T get(){
return f.get().get();
}
};
int adder(problem<int>& a, problem<int>& b) {
return a.get() + b.get();
}
int main() {
std::map<char, problem<int>> scheme;
scheme['c'].set([] { return 1;} );
scheme['a'].set(adder, std::ref(scheme['b']), std::ref(scheme['c']));
scheme['b'].set([] { return 3;} );
std::cout << scheme['a'].get() << '\n';
}
可能有更简单的方法。
我正在尝试使用 std::future
和 std::async
实现一个简单的依赖关系求解器。目前我不明白是否有可能做到这一点。问题是,我们可以将(尚不可用)future
传递给 async
调用吗?如果没有,实际上可以做些什么来让一些 尚未准备好 输入相互调用的函数链?也许,可以覆盖传递给延迟异步的值?
可能是我的描述看不懂,举个例子:
#include <iostream>
#include <future>
#include <map>
using namespace std;
int adder(future<int> a, future<int> b) {
return a.get() + b.get();
}
int main() {
map<char, future<int>> scheme;
scheme['c'] = future<int>(async(launch::deferred, [] { return 1;}));
scheme['a'] = future<int>(async(launch::deferred, adder, move(scheme['b']), move(scheme['c'])));
scheme['b'] = future<int>(async(launch::deferred, [] { return 3;}));
cout << scheme['a'].get() << endl;
}
我们应该有这样的方案:
c
\
a ----- result
/
b
以及 4
的结果。
此代码失败:move
只接受一个空的 future
并将其传递给 adder
。如果我们用 'a'
和 'b'
交换行,它会工作正常,但这样我们应该已经知道依赖关系了。
使用承诺。也许未来的未来。
template<class T>
struct problem {
std::promise<std::shared_future<T>> p;
std::shared_future<std::shared_future<T>> f;
problem():f(p.get_future()){}
template<class W, class...Args>
void set(W&&work, Args&&...args){
p.set_value(std::async(std::launch::deferred, std::forward<W>(work), std::forward<Args>(args)...));
}
T get(){
return f.get().get();
}
};
int adder(problem<int>& a, problem<int>& b) {
return a.get() + b.get();
}
int main() {
std::map<char, problem<int>> scheme;
scheme['c'].set([] { return 1;} );
scheme['a'].set(adder, std::ref(scheme['b']), std::ref(scheme['c']));
scheme['b'].set([] { return 3;} );
std::cout << scheme['a'].get() << '\n';
}
可能有更简单的方法。