Skip to content

Commit ea54d5a

Browse files
tsung-wei-huangtsung-wei-huang
committed
updated core
1 parent 24e3ddc commit ea54d5a

4 files changed

Lines changed: 75 additions & 75 deletions

File tree

‎example/reduce.cpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ void reduce() {
3333
auto send = std::chrono::steady_clock::now();
3434
std::cout << "[sequential] reduce: "
3535
<< std::chrono::duration_cast<std::chrono::milliseconds>(send - sbeg).count()
36-
<< std::endl;
36+
<< " ms\n";
3737

3838
// taskflow
3939
auto tbeg = std::chrono::steady_clock::now();
@@ -46,7 +46,7 @@ void reduce() {
4646
auto tend = std::chrono::steady_clock::now();
4747
std::cout << "[taskflow] reduce: "
4848
<< std::chrono::duration_cast<std::chrono::milliseconds>(tend - tbeg).count()
49-
<< std::endl;
49+
<< " ms\n";
5050

5151
// assertion
5252
assert(tmin == smin);
@@ -68,7 +68,7 @@ void transform_reduce() {
6868
auto send = std::chrono::steady_clock::now();
6969
std::cout << "[sequential] transform_reduce "
7070
<< std::chrono::duration_cast<std::chrono::milliseconds>(send - sbeg).count()
71-
<< std::endl;
71+
<< " ms\n";
7272

7373
// taskflow
7474
auto tbeg = std::chrono::steady_clock::now();
@@ -82,7 +82,7 @@ void transform_reduce() {
8282
auto tend = std::chrono::steady_clock::now();
8383
std::cout << "[taskflow] transform_reduce "
8484
<< std::chrono::duration_cast<std::chrono::milliseconds>(tend - tbeg).count()
85-
<< std::endl;
85+
<< " ms\n";
8686

8787
// assertion
8888
assert(tmin == smin);

‎taskflow/taskflow.hpp‎

Lines changed: 40 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -207,21 +207,21 @@ class BasicFlowBuilder;
207207
template <typename NodeType>
208208
class BasicSubflowBuilder;
209209

210-
template <template <typename...> typename Func, typename ThreadpoolType>
210+
template <template <typename...> typename F, typename ThreadpoolType>
211211
class BasicTaskflow;
212212

213213
// ----------------------------------------------------------------------------
214214

215215
// Class: BasicNode
216-
template <template<typename...> typename Func>
216+
template <template<typename...> typename F>
217217
class BasicNode {
218218

219219
template <typename U> friend class BasicTask;
220220
template <typename S> friend class BasicTopology;
221-
template <template <typename...> class F, typename P> friend class BasicTaskflow;
221+
template <template <typename...> class X, typename Y> friend class BasicTaskflow;
222222

223-
using WorkType = Func<void()>;
224-
using SubworkType = Func<void(BasicSubflowBuilder<BasicNode>&)>;
223+
using WorkType = F<void()>;
224+
using SubworkType = F<void(BasicSubflowBuilder<BasicNode>&)>;
225225
using TopologyType = BasicTopology<BasicNode>;
226226

227227
public:
@@ -253,57 +253,57 @@ class BasicNode {
253253
};
254254

255255
// Constructor
256-
template <template<typename...> typename Func>
257-
BasicNode<Func>::BasicNode() {
256+
template <template<typename...> typename F>
257+
BasicNode<F>::BasicNode() {
258258
_dependents.store(0, std::memory_order_relaxed);
259259
_topology = nullptr;
260260
}
261261

262262
// Constructor
263-
template <template<typename...> typename Func>
263+
template <template<typename...> typename F>
264264
template <typename C>
265-
BasicNode<Func>::BasicNode(C&& c) : _work {std::forward<C>(c)} {
265+
BasicNode<F>::BasicNode(C&& c) : _work {std::forward<C>(c)} {
266266
_dependents.store(0, std::memory_order_relaxed);
267267
_topology = nullptr;
268268
}
269269

270270
// Procedure:
271-
template <template<typename...> typename Func>
272-
void BasicNode<Func>::precede(BasicNode& v) {
271+
template <template<typename...> typename F>
272+
void BasicNode<F>::precede(BasicNode& v) {
273273
_successors.push_back(&v);
274274
//++v._dependents;
275275
v._dependents.fetch_add(1, std::memory_order_relaxed);
276276
}
277277

278278
// Function: num_successors
279-
template <template<typename...> typename Func>
280-
size_t BasicNode<Func>::num_successors() const {
279+
template <template<typename...> typename F>
280+
size_t BasicNode<F>::num_successors() const {
281281
return _successors.size();
282282
}
283283

284284
// Function: dependents
285-
template <template<typename...> typename Func>
286-
size_t BasicNode<Func>::num_dependents() const {
285+
template <template<typename...> typename F>
286+
size_t BasicNode<F>::num_dependents() const {
287287
return _dependents.load(std::memory_order_relaxed);
288288
}
289289

290290
// Function: name
291-
template <template<typename...> typename Func>
292-
const std::string& BasicNode<Func>::name() const {
291+
template <template<typename...> typename F>
292+
const std::string& BasicNode<F>::name() const {
293293
return _name;
294294
}
295295

296296
// Function: dump
297-
template <template<typename...> typename Func>
298-
std::string BasicNode<Func>::dump() const {
297+
template <template<typename...> typename F>
298+
std::string BasicNode<F>::dump() const {
299299
std::ostringstream os;
300300
_dump(os);
301301
return os.str();
302302
}
303303

304304
// Function: _dump
305-
template <template<typename...> typename Func>
306-
void BasicNode<Func>::_dump(std::ostream& os) const {
305+
template <template<typename...> typename F>
306+
void BasicNode<F>::_dump(std::ostream& os) const {
307307

308308
if(_name.empty()) os << '\"' << this << '\"';
309309
else os << std::quoted(_name);
@@ -1293,20 +1293,20 @@ void BasicTaskflow<F, P>::num_workers(size_t W) {
12931293
_threadpool.spawn(W);
12941294
}
12951295

1296-
// Ftion: num_nodes
1296+
// Function: num_nodes
12971297
template <template <typename...> typename F, typename P>
12981298
size_t BasicTaskflow<F, P>::num_nodes() const {
12991299
//return _nodes.size();
13001300
return std::distance(_nodes.begin(), _nodes.end());
13011301
}
13021302

1303-
// Ftion: num_workers
1303+
// Function: num_workers
13041304
template <template <typename...> typename F, typename P>
13051305
size_t BasicTaskflow<F, P>::num_workers() const {
13061306
return _threadpool.num_workers();
13071307
}
13081308

1309-
// Ftion: num_topologies
1309+
// Function: num_topologies
13101310
template <template <typename...> typename F, typename P>
13111311
size_t BasicTaskflow<F, P>::num_topologies() const {
13121312
return _topologies.size();
@@ -1343,13 +1343,13 @@ void BasicTaskflow<F, P>::broadcast(TaskType from, std::initializer_list<TaskTyp
13431343
}
13441344

13451345

1346-
// Ftion: gather
1346+
// Function: gather
13471347
template <template <typename...> typename F, typename P>
13481348
void BasicTaskflow<F, P>::gather(std::vector<TaskType>& keys, TaskType to) {
13491349
to.gather(keys);
13501350
}
13511351

1352-
// Ftion: gather
1352+
// Function: gather
13531353
template <template <typename...> typename F, typename P>
13541354
void BasicTaskflow<F, P>::gather(std::initializer_list<TaskType> keys, TaskType to) {
13551355
to.gather(keys);
@@ -1401,41 +1401,41 @@ void BasicTaskflow<F, P>::wait_for_topologies() {
14011401
_topologies.clear();
14021402
}
14031403

1404-
// Ftion: placeholder
1404+
// Function: placeholder
14051405
template <template <typename...> typename F, typename P>
14061406
auto BasicTaskflow<F, P>::placeholder() {
14071407
return FlowBuilderType(_nodes, num_workers()).placeholder();
14081408
}
14091409

1410-
// Ftion: silent_emplace
1410+
// Function: silent_emplace
14111411
template <template <typename...> typename F, typename P>
14121412
template <typename C>
14131413
auto BasicTaskflow<F, P>::silent_emplace(C&& c) {
14141414
return FlowBuilderType(_nodes, num_workers()).silent_emplace(std::forward<C>(c));
14151415
}
14161416

1417-
// Ftion: silent_emplace
1417+
// Function: silent_emplace
14181418
template <template <typename...> typename F, typename P>
14191419
template <typename... C, std::enable_if_t<(sizeof...(C)>1), void>*>
14201420
auto BasicTaskflow<F, P>::silent_emplace(C&&... cs) {
14211421
return FlowBuilderType(_nodes, num_workers()).silent_emplace(std::forward<C>(cs)...);
14221422
}
14231423

1424-
// Ftion: emplace
1424+
// Function: emplace
14251425
template <template <typename...> typename F, typename P>
14261426
template <typename C>
14271427
auto BasicTaskflow<F, P>::emplace(C&& c) {
14281428
return FlowBuilderType(_nodes, num_workers()).emplace(std::forward<C>(c));
14291429
}
14301430

1431-
// Ftion: emplace
1431+
// Function: emplace
14321432
template <template <typename...> typename F, typename P>
14331433
template <typename... C, std::enable_if_t<(sizeof...(C)>1), void>*>
14341434
auto BasicTaskflow<F, P>::emplace(C&&... cs) {
14351435
return FlowBuilderType(_nodes, num_workers()).emplace(std::forward<C>(cs)...);
14361436
}
14371437

1438-
// Ftion: parallel_for
1438+
// Function: parallel_for
14391439
template <template <typename...> typename F, typename P>
14401440
template <typename I, typename C>
14411441
auto BasicTaskflow<F, P>::parallel_for(I beg, I end, C&& c, size_t g) {
@@ -1444,7 +1444,7 @@ auto BasicTaskflow<F, P>::parallel_for(I beg, I end, C&& c, size_t g) {
14441444
);
14451445
}
14461446

1447-
// Ftion: parallel_for
1447+
// Function: parallel_for
14481448
template <template <typename...> typename F, typename P>
14491449
template <typename T, typename C, std::enable_if_t<is_iterable_v<T>, void>*>
14501450
auto BasicTaskflow<F, P>::parallel_for(T& t, C&& c, size_t group) {
@@ -1453,7 +1453,7 @@ auto BasicTaskflow<F, P>::parallel_for(T& t, C&& c, size_t group) {
14531453
);
14541454
}
14551455

1456-
// Ftion: reduce
1456+
// Function: reduce
14571457
template <template <typename...> typename F, typename P>
14581458
template <typename I, typename T, typename B>
14591459
auto BasicTaskflow<F, P>::reduce(I beg, I end, T& result, B&& op) {
@@ -1462,7 +1462,7 @@ auto BasicTaskflow<F, P>::reduce(I beg, I end, T& result, B&& op) {
14621462
);
14631463
}
14641464

1465-
// Ftion: reduce_min
1465+
// Function: reduce_min
14661466
// Find the minimum element over a range of items.
14671467
template <template <typename...> typename F, typename P>
14681468
template <typename I, typename T>
@@ -1472,7 +1472,7 @@ auto BasicTaskflow<F, P>::reduce_min(I beg, I end, T& result) {
14721472
});
14731473
}
14741474

1475-
// Ftion: reduce_max
1475+
// Function: reduce_max
14761476
// Find the maximum element over a range of items.
14771477
template <template <typename...> typename F, typename P>
14781478
template <typename I, typename T>
@@ -1482,7 +1482,7 @@ auto BasicTaskflow<F, P>::reduce_max(I beg, I end, T& result) {
14821482
});
14831483
}
14841484

1485-
// Ftion: transform_reduce
1485+
// Function: transform_reduce
14861486
template <template <typename...> typename F, typename P>
14871487
template <typename I, typename T, typename B, typename U>
14881488
auto BasicTaskflow<F, P>::transform_reduce(
@@ -1493,7 +1493,7 @@ auto BasicTaskflow<F, P>::transform_reduce(
14931493
);
14941494
}
14951495

1496-
// Ftion: transform_reduce
1496+
// Function: transform_reduce
14971497
template <template <typename...> typename F, typename P>
14981498
template <typename I, typename T, typename B, typename R, typename U>
14991499
auto BasicTaskflow<F, P>::transform_reduce(
@@ -1579,7 +1579,7 @@ void BasicTaskflow<F, P>::_schedule(NodeType& node) {
15791579
});
15801580
}
15811581

1582-
// Ftion: dump_topology
1582+
// Function: dump_topology
15831583
template <template <typename...> typename F, typename P>
15841584
std::string BasicTaskflow<F, P>::dump_topologies() const {
15851585

@@ -1592,7 +1592,7 @@ std::string BasicTaskflow<F, P>::dump_topologies() const {
15921592
return os.str();
15931593
}
15941594

1595-
// Ftion: dump
1595+
// Function: dump
15961596
// Dumps the taskflow in graphviz. The result can be viewed at http://www.webgraphviz.com/.
15971597
template <template <typename...> typename F, typename P>
15981598
std::string BasicTaskflow<F, P>::dump() const {

0 commit comments

Comments
 (0)