Skip to content

Commit 2bfb070

Browse files
taehyounparktaehyounpark
committed
Clean
1 parent 8d53219 commit 2bfb070

File tree

4 files changed

+91
-80
lines changed

4 files changed

+91
-80
lines changed

‎include/ana/interface/dataflow.h

Lines changed: 40 additions & 41 deletions
Original file line numberDiff line numberDiff line change
@@ -263,7 +263,7 @@ ana::dataset::reader<DS> ana::dataflow::open(Args &&...args) {
263263
// open dataset reader and processor for each thread
264264
// slot for each partition range
265265
this->m_players = lockstep::get_node(
266-
[ds](dataset::range &part) { return ds->open_player(part); },
266+
[ds](dataset::range *part) { return ds->open_player(*part); },
267267
this->m_parts);
268268
this->m_processors = lockstep::node<dataset::processor>(
269269
m_parts.concurrency(), this->m_weight / this->m_norm);
@@ -275,8 +275,8 @@ template <typename DS, typename Val>
275275
auto ana::dataflow::read(dataset::input<DS> &ds, const std::string &name)
276276
-> lazy<read_column_t<DS, Val>> {
277277
auto act = lockstep::get_node(
278-
[name, &ds](dataset::processor &proc, dataset::range &part) {
279-
return proc.template read<DS, Val>(std::ref(ds), part, name);
278+
[name, &ds](dataset::processor *proc, dataset::range *part) {
279+
return proc->template read<DS, Val>(std::ref(ds), *part, name);
280280
},
281281
this->m_processors, this->m_parts);
282282
auto lzy = lazy<read_column_t<DS, Val>>(*this, act);
@@ -288,8 +288,8 @@ template <typename Val>
288288
auto ana::dataflow::constant(Val const &val)
289289
-> lazy<ana::column::constant<Val>> {
290290
auto act = lockstep::get_node(
291-
[&val](dataset::processor &proc) {
292-
return proc.template constant<Val>(val);
291+
[&val](dataset::processor *proc) {
292+
return proc->template constant<Val>(val);
293293
},
294294
this->m_processors);
295295
auto lzy = lazy<column::constant<Val>>(*this, act);
@@ -301,8 +301,8 @@ template <typename Val, typename... Args>
301301
auto ana::dataflow::constant(Args &&...args)
302302
-> lazy<ana::column::constant<Val>> {
303303
auto act = lockstep::get_node(
304-
[args...](dataset::processor &proc) {
305-
return proc.template constant<Val>(std::forward<Args>(args)...);
304+
[args...](dataset::processor *proc) {
305+
return proc->template constant<Val>(std::forward<Args>(args)...);
306306
},
307307
this->m_processors);
308308
auto lzy = lazy<column::constant<Val>>(*this, act);
@@ -315,17 +315,17 @@ auto ana::dataflow::define(Args &&...args) {
315315
return delayed<ana::column::template evaluator_t<Def>>(
316316
*this,
317317
lockstep::get_node(
318-
[&args...](dataset::processor &proc) {
319-
return proc.template define<Def>(std::forward<Args>(args)...);
318+
[&args...](dataset::processor *proc) {
319+
return proc->template define<Def>(std::forward<Args>(args)...);
320320
},
321321
this->m_processors));
322322
}
323323

324324
template <typename F> auto ana::dataflow::define(F const &callable) {
325325
return delayed<ana::column::template evaluator_t<F>>(
326326
*this, lockstep::get_node(
327-
[callable](dataset::processor &proc) {
328-
return proc.template define(callable);
327+
[callable](dataset::processor *proc) {
328+
return proc->template define(callable);
329329
},
330330
this->m_processors));
331331
}
@@ -369,8 +369,8 @@ auto ana::dataflow::select(const std::string &name, F callable)
369369
-> delayed<selection::template custom_applicator_t<F>> {
370370
return delayed<selection::template custom_applicator_t<F>>(
371371
*this, lockstep::get_node(
372-
[name, callable](dataset::processor &proc) {
373-
return proc.template select<Sel>(nullptr, name, callable);
372+
[name, callable](dataset::processor *proc) {
373+
return proc->template select<Sel>(nullptr, name, callable);
374374
},
375375
this->m_processors));
376376
}
@@ -380,8 +380,8 @@ auto ana::dataflow::channel(const std::string &name, F callable)
380380
-> delayed<selection::template custom_applicator_t<F>> {
381381
return delayed<selection::template custom_applicator_t<F>>(
382382
*this, lockstep::get_node(
383-
[name = name, callable = callable](dataset::processor &proc) {
384-
return proc.template channel<Sel>(nullptr, name, callable);
383+
[name, callable](dataset::processor *proc) {
384+
return proc->template channel<Sel>(nullptr, name, callable);
385385
},
386386
this->m_processors));
387387
}
@@ -390,8 +390,8 @@ template <typename Cnt, typename... Args>
390390
auto ana::dataflow::agg(Args &&...args) -> delayed<aggregation::booker<Cnt>> {
391391
return delayed<aggregation::booker<Cnt>>(
392392
*this, lockstep::get_node(
393-
[&args...](dataset::processor &proc) {
394-
return proc.template book<Cnt>(std::forward<Args>(args)...);
393+
[&args...](dataset::processor *proc) {
394+
return proc->template book<Cnt>(std::forward<Args>(args)...);
395395
},
396396
this->m_processors));
397397
}
@@ -417,8 +417,8 @@ auto ana::dataflow::select(lazy<selection> const &prev, const std::string &name,
417417
return delayed<selection::template custom_applicator_t<F>>(
418418
*this,
419419
lockstep::get_node(
420-
[name, callable](dataset::processor &proc, selection const &prev) {
421-
return proc.template select<Sel>(&prev, name, callable);
420+
[name, callable](dataset::processor *proc, selection const *prev) {
421+
return proc->template select<Sel>(prev, name, callable);
422422
},
423423
this->m_processors, prev));
424424
}
@@ -428,21 +428,21 @@ auto ana::dataflow::channel(lazy<selection> const &prev,
428428
const std::string &name, F callable)
429429
-> delayed<selection::template custom_applicator_t<F>> {
430430
return delayed<selection::template custom_applicator_t<F>>(
431-
*this, lockstep::get_node(
432-
[name = name, callable = callable](dataset::processor &proc,
433-
selection const &prev) {
434-
return proc.template channel<Sel>(&prev, name, callable);
435-
},
436-
this->m_processors, prev));
431+
*this,
432+
lockstep::get_node(
433+
[name, callable](dataset::processor *proc, selection const *prev) {
434+
return proc->template channel<Sel>(prev, name, callable);
435+
},
436+
this->m_processors, prev));
437437
}
438438

439439
template <typename Def, typename... Cols>
440440
auto ana::dataflow::evaluate_column(delayed<column::evaluator<Def>> const &calc,
441441
lazy<Cols> const &...columns) -> lazy<Def> {
442442
auto act = lockstep::get_node(
443-
[](dataset::processor &proc, column::evaluator<Def> &calc,
444-
Cols const &...cols) {
445-
return proc.template evaluate_column(calc, cols...);
443+
[](dataset::processor *proc, column::evaluator<Def> *calc,
444+
Cols const *...cols) {
445+
return proc->template evaluate_column(*calc, *cols...);
446446
},
447447
this->m_processors, calc, columns...);
448448
auto lzy = lazy<Def>(*this, act);
@@ -455,9 +455,9 @@ auto ana::dataflow::apply_selection(
455455
delayed<selection::applicator<Eqn>> const &calc,
456456
lazy<Cols> const &...columns) -> lazy<selection> {
457457
auto act = lockstep::get_node(
458-
[](dataset::processor &proc, selection::applicator<Eqn> &calc,
459-
Cols &...cols) {
460-
return proc.template apply_selection(calc, cols...);
458+
[](dataset::processor *proc, selection::applicator<Eqn> *calc,
459+
Cols *...cols) {
460+
return proc->template apply_selection(*calc, *cols...);
461461
},
462462
this->m_processors, calc, columns...);
463463
auto lzy = lazy<selection>(*this, act);
@@ -473,8 +473,8 @@ auto ana::dataflow::select_aggregation(
473473
// its status
474474
this->reset();
475475
auto act = lockstep::get_node(
476-
[](dataset::processor &proc, aggregation::booker<Cnt> &bkr,
477-
const selection &sel) { return proc.select_aggregation(bkr, sel); },
476+
[](dataset::processor *proc, aggregation::booker<Cnt> *bkr,
477+
const selection *sel) { return proc->select_aggregation(*bkr, *sel); },
478478
this->m_processors, bkr, sel);
479479
auto lzy = lazy<Cnt>(*this, act);
480480
this->add_operation(std::move(act));
@@ -492,10 +492,11 @@ auto ana::dataflow::select_aggregations(
492492
using delayed_bookkeeper_type = delayed<aggregation::bookkeeper<Cnt>>;
493493
auto bkpr = delayed_bookkeeper_type(
494494
*this, lockstep::get_node(
495-
[this](dataset::processor &proc, aggregation::booker<Cnt> &bkr,
496-
Sels const &...sels) {
495+
[this](dataset::processor *proc, aggregation::booker<Cnt> *bkr,
496+
Sels const *...sels) {
497497
// get bookkeeper and aggregations
498-
auto bkpr_and_cntrs = proc.select_aggregations(bkr, sels...);
498+
auto bkpr_and_cntrs =
499+
proc->select_aggregations(*bkr, *sels...);
499500

500501
// add each aggregation to this dataflow
501502
for (auto &&cntr : bkpr_and_cntrs.second) {
@@ -506,8 +507,6 @@ auto ana::dataflow::select_aggregations(
506507
return std::move(bkpr_and_cntrs.first);
507508
},
508509
this->m_processors, bkr, sels...));
509-
// lockstep::node<aggregation::booker<Cnt>>(bkr), sels...));
510-
511510
return bkpr;
512511
}
513512

@@ -522,15 +521,15 @@ inline void ana::dataflow::analyze() {
522521
m_source->initialize();
523522

524523
this->m_mtcfg.run(
525-
[](dataset::processor &proc, dataset::player &plyr,
526-
const dataset::range &part) { proc.process(plyr, part); },
524+
[](dataset::processor *proc, dataset::player *plyr,
525+
const dataset::range *part) { proc->process(*plyr, *part); },
527526
this->m_processors, this->m_players, this->m_parts);
528527

529528
m_source->finalize();
530529

531530
// clear aggregations so they are not run more than once
532531
this->m_processors.call_all_slots(
533-
[](dataset::processor &proc) { proc.clear_aggregations(); });
532+
[](dataset::processor *proc) { proc->clear_aggregations(); });
534533
}
535534

536535
inline void ana::dataflow::reset() { m_analyzed = false; }

‎include/ana/interface/delayed.h

Lines changed: 7 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -132,7 +132,7 @@ class delayed : public systematic::resolver<delayed<Bkr>>,
132132
bool> = false>
133133
auto list_selection_paths() const -> std::set<std::string> {
134134
return lockstep::get_value(
135-
[](Bkr const &bkpr) { return bkpr.list_selection_paths(); },
135+
[](Bkr const *bkpr) { return bkpr->list_selection_paths(); },
136136
std::cref(*this));
137137
}
138138

@@ -270,10 +270,10 @@ class delayed : public systematic::resolver<delayed<Bkr>>,
270270
-> lazy<aggregation::booked_t<V>> {
271271
return lazy<aggregation::booked_t<V>>(
272272
*this->m_df, lockstep::get_view(
273-
[selection_path = selection_path](V &bkpr) {
274-
return bkpr.get_aggregation(selection_path);
273+
[selection_path](V *bkpr) {
274+
return bkpr->get_aggregation(selection_path);
275275
},
276-
this->get_view()));
276+
*this));
277277
}
278278

279279
template <typename... Args, typename V = Bkr,
@@ -302,10 +302,10 @@ class delayed : public systematic::resolver<delayed<Bkr>>,
302302
return delayed<V>(
303303
*this->m_df,
304304
lockstep::get_node(
305-
[](V &fillable, typename Nodes::operation_type &...cols) {
306-
return fillable.book_fill(cols...);
305+
[](V *fillable, typename Nodes::operation_type *...cols) {
306+
return fillable->book_fill(*cols...);
307307
},
308-
this->get_view(), columns...));
308+
*this, columns...));
309309
}
310310

311311
template <typename... Nodes, typename V = Bkr,

‎include/ana/interface/delayed_varied.h

Lines changed: 25 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -5,11 +5,10 @@
55
namespace ana {
66

77
/**
8-
* @brief Varied version of a delayed operation.
9-
* @details A delayed varied operation can be considered to be functionally
10-
* equivalent to a delayed operation, except that it contains multipled delayed
11-
* ones for which the operation is applied. The nominal delayed operation can be
12-
* accessed by `nominal()`, and a systematic variation by `["variation name"]`.
8+
* @brief Varied version of a delayed node.
9+
* @details A delayed varied operation is functionally equivalent to a delayed
10+
* node, except that it contains multiple nodes corresponding to nominal and
11+
* systematic variations.
1312
*/
1413
template <typename Bld>
1514
class delayed<Bld>::varied : public systematic::resolver<delayed<Bld>> {
@@ -42,31 +41,50 @@ class delayed<Bld>::varied : public systematic::resolver<delayed<Bld>> {
4241
bool> = false>
4342
auto apply(Nodes const &...columns) -> typename lazy<selection>::varied;
4443

44+
/**
45+
* @brief Fill aggregation logic with input columns.
46+
*/
4547
template <
4648
typename... Nodes, typename V = Bld,
4749
std::enable_if_t<ana::aggregation::template is_booker_v<V>, bool> = false>
4850
auto fill(Nodes const &...columns) -> varied;
4951

52+
/**
53+
* @brief Book the aggregation logic at a selection.
54+
* @param selection Lazy(varied) selection node to book aggregation
55+
* at.
56+
*/
5057
template <
5158
typename Node, typename V = Bld,
5259
std::enable_if_t<ana::aggregation::template is_booker_v<V>, bool> = false>
5360
auto book(Node const &selection) ->
5461
typename lazy<aggregation::booked_t<V>>::varied;
5562

63+
/**
64+
* @brief Book the aggregation logic at multiple selections.
65+
* @param selection Lazy selection nodes to book aggregations at.
66+
* @return Lazy aggregation node.
67+
*/
5668
template <
5769
typename... Nodes, typename V = Bld,
5870
std::enable_if_t<ana::aggregation::template is_booker_v<V>, bool> = false>
5971
auto book(Nodes const &...selections) -> typename delayed<
6072
aggregation::bookkeeper<aggregation::booked_t<V>>>::varied;
6173

74+
/**
75+
* @brief Evaluate/apply the column definition/selection with input columns.
76+
* @param args... Lazy input column nodes
77+
* @return Lazy column definition node
78+
*/
6279
template <typename... Args>
6380
auto operator()(Args &&...args) ->
6481
typename lazy<typename decltype(std::declval<delayed<Bld>>().operator()(
6582
std::forward<Args>(args).nominal()...))::operation_type>::varied;
6683

6784
/**
68-
* @brief Access the delayed operation of a specific systematic variation.
69-
* @param var_name The name of the systematic variation.
85+
* @brief Access the delayed node of a specific systematic variation.
86+
* @param var_name Name of the systematic variation.
87+
* @return Delayed node corresponding to systematic variation.
7088
*/
7189
template <typename V = Bld,
7290
std::enable_if_t<ana::aggregation::template is_bookkeeper_v<V>,

0 commit comments

Comments
 (0)