799 lines
34 KiB
C++
799 lines
34 KiB
C++
/* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
|
|
|
|
/*!
|
|
* \link
|
|
* \file optimize.hpp
|
|
* \ingroup building_blocks
|
|
*
|
|
* \brief FastFlow optimization heuristics
|
|
*
|
|
* @detail FastFlow basic container for a shared-memory parallel activity
|
|
*
|
|
*/
|
|
|
|
#ifndef FF_OPTIMIZE_HPP
|
|
#define FF_OPTIMIZE_HPP
|
|
|
|
/* ***************************************************************************
|
|
*
|
|
* FastFlow is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU Lesser General Public License version 3 as
|
|
* published by the Free Software Foundation.
|
|
* Starting from version 3.0.1 FastFlow is dual licensed under the GNU LGPLv3
|
|
* or MIT License (https://github.com/ParaGroup/WindFlow/blob/vers3.x/LICENSE.MIT)
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
|
|
* License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
*
|
|
****************************************************************************
|
|
*/
|
|
|
|
/*
|
|
* Author: Massimo Torquati
|
|
*
|
|
*/
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstdarg>
|
|
#include <ff/node.hpp>
|
|
#include <ff/pipeline.hpp>
|
|
#include <ff/farm.hpp>
|
|
#include <ff/all2all.hpp>
|
|
#include <ff/combine.hpp>
|
|
|
|
namespace ff {
|
|
|
|
typedef enum { OPT_NORMAL = 1, OPT_INFO = 2 } reportkind_t;
|
|
static inline void opt_report(int verbose_level, reportkind_t kind, const char *str, ...) {
|
|
if (verbose_level < kind) return;
|
|
va_list argp;
|
|
char * p=(char *)malloc(strlen(str)+512); // this is dangerous.....
|
|
assert(p);
|
|
strcpy(p, str);
|
|
va_start(argp, str);
|
|
vfprintf(stdout, p, argp);
|
|
va_end(argp);
|
|
free(p);
|
|
}
|
|
|
|
/**
|
|
* This function looks for internal farms with default collector in a farm building block.
|
|
* The internal default collectors are removed.
|
|
*/
|
|
static inline int remove_internal_collectors(ff_farm& farm) {
|
|
const svector<ff_node*>& W = farm.getWorkers();
|
|
for(size_t i=0;i<W.size();++i) {
|
|
if (W[i]->isFarm() && !W[i]->isOFarm()) {
|
|
ff_farm* ifarm = reinterpret_cast<ff_farm*>(W[i]);
|
|
if (remove_internal_collectors(*ifarm)<0) return -1;
|
|
if (ifarm->getCollector() == nullptr)
|
|
ifarm->remove_collector();
|
|
} else {
|
|
if (W[i]->isPipe()) {
|
|
ff_pipeline* ipipe = reinterpret_cast<ff_pipeline*>(W[i]);
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
if (optimize_static(*ipipe, iopt)<0) return -1;
|
|
}
|
|
if (W[i]->isAll2All()) {
|
|
ff_a2a *a2a = reinterpret_cast<ff_a2a*>(W[i]);
|
|
const svector<ff_node*>& W1 = a2a->getFirstSet();
|
|
const svector<ff_node*>& W2 = a2a->getSecondSet();
|
|
for(size_t j=0;j<W1.size();++j) {
|
|
if (W1[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W1[j]);
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
if (optimize_static(*ipipe, iopt)<0) return -1;
|
|
}
|
|
}
|
|
for(size_t j=0;j<W2.size();++j) {
|
|
if (W2[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W2[j]);
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
if (optimize_static(*ipipe, iopt)<0) return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* It combines the node passed as second parameter with the farm's emitter.
|
|
* The node is added at the left-hand side of the emitter.
|
|
* This transformation is logically equivalent to the following pipeline: ff_Pipe<> pipe(node, farm);
|
|
*/
|
|
static inline int combine_with_emitter(ff_farm& farm, ff_node*node, bool cleanup_node=false) {
|
|
if (node->isFarm() || node->isPipe() || node->isAll2All()) {
|
|
error("combine_with_emitter: the node to combine cannot be a parallel building block\n");
|
|
return -1;
|
|
}
|
|
ff_node* emitter = farm.getEmitter();
|
|
if (!emitter) {
|
|
farm.add_emitter(node);
|
|
farm.cleanup_emitter(cleanup_node);
|
|
return 0;
|
|
}
|
|
ff_comb* comb;
|
|
|
|
if (!emitter->isMultiOutput()) {
|
|
internal_mo_transformer *mo_emitter = new internal_mo_transformer(emitter,
|
|
farm.isset_cleanup_emitter());
|
|
comb = new ff_comb(node, mo_emitter, cleanup_node, true);
|
|
} else {
|
|
comb = new ff_comb(node,emitter,
|
|
cleanup_node, farm.isset_cleanup_emitter());
|
|
|
|
}
|
|
if (farm.isset_cleanup_emitter())
|
|
farm.cleanup_emitter(false);
|
|
|
|
farm.change_emitter(comb, true);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* It combines the node passed as parameter with the farm's collector.
|
|
* The node is added at the right-hand side of the collector.
|
|
* This transformation is logically equivalent to the following pipeline: ff_Pipe<> pipe(farm, node);
|
|
*/
|
|
static inline int combine_with_collector(ff_farm& farm, ff_node*node, bool cleanup_node=false) {
|
|
if (!farm.getCollector()) {
|
|
error("combine_with_collector: the farm passed as parameter does not have a collector\n");
|
|
return -1;
|
|
}
|
|
if (node->isFarm() || node->isPipe() || node->isAll2All()) {
|
|
error("combine_with_emitter: the node to combine cannot be a parallel building block\n");
|
|
return -1;
|
|
}
|
|
ff_node* collector = farm.getCollector();
|
|
ff_comb* comb = new ff_comb(collector, node,
|
|
farm.isset_cleanup_collector(), cleanup_node);
|
|
if (farm.isset_cleanup_collector())
|
|
farm.cleanup_collector(false);
|
|
farm.remove_collector();
|
|
farm.add_collector(comb, true);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* It combines the node passed as parameter with the first stage of the pipeline.
|
|
* The node is added at the left-hand side of the first pipeline node.
|
|
* This transformation is logically equivalent to the following pipeline: ff_Pipe<> pipe2(node, pipe);
|
|
*/
|
|
template<typename T>
|
|
static inline int combine_with_firststage(ff_pipeline& pipe, T* node, bool cleanup_node) {
|
|
pipe.flatten();
|
|
ff_node* node0 = pipe.get_node(0); // it cannot be a pipeline
|
|
if (!node0) {
|
|
error("combine_with_firststage: empty pipeline\n");
|
|
return -1;
|
|
}
|
|
if (node0->isAll2All()) {
|
|
return combine_left_with_a2a(*reinterpret_cast<ff_a2a*>(node0), node, cleanup_node);
|
|
}
|
|
if (node0->isFarm()) {
|
|
ff_farm &farm=*(ff_farm*)node0;
|
|
if (combine_with_emitter(farm, node, cleanup_node)<0) return -1;
|
|
pipe.remove_stage(0);
|
|
pipe.insert_stage(0, node0);
|
|
} else {
|
|
ff_comb* comb = new ff_comb(node, node0, cleanup_node);
|
|
pipe.remove_stage(0);
|
|
pipe.insert_stage(0, comb, true);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
template<typename T>
|
|
static inline int combine_right_with_farm(ff_farm& farm, T* node, bool cleanup_node) {
|
|
if (farm.hasCollector())
|
|
return combine_with_collector(farm, node, cleanup_node);
|
|
|
|
// farm with no collector
|
|
const svector<ff_node*>& w= farm.getWorkers();
|
|
assert(w.size()>0);
|
|
|
|
if (w[0]->isPipe()) { // NOTE: we suppose that all workers are homogeneous
|
|
if (combine_with_laststage(*reinterpret_cast<ff_pipeline*>(w[0]), node, cleanup_node)<0) return -1;
|
|
int r=0;
|
|
for(size_t i=1;i<w.size();++i) {
|
|
ff_pipeline* pipe = reinterpret_cast<ff_pipeline*>(w[i]);
|
|
r+=combine_with_laststage(*pipe, new T(*node), true);
|
|
}
|
|
return (r>0?-1:0);
|
|
}
|
|
if (w[0]->isFarm()) {
|
|
if (combine_right_with_farm(*reinterpret_cast<ff_farm*>(w[0]), node, cleanup_node)<0) return -1;
|
|
int r=0;
|
|
for(size_t i=1;i<w.size();++i) {
|
|
ff_farm* farm = reinterpret_cast<ff_farm*>(w[i]);
|
|
r+=combine_right_with_farm(*farm, new T(*node), true);
|
|
}
|
|
return (r>0?-1:0);
|
|
}
|
|
if (w[0]->isAll2All()) {
|
|
if (combine_right_with_a2a(*reinterpret_cast<ff_a2a*>(w[0]), node, cleanup_node)<0) return -1;
|
|
int r=0;
|
|
for(size_t i=1;i<w.size();++i) {
|
|
ff_a2a* a2a = reinterpret_cast<ff_a2a*>(w[i]);
|
|
r+=combine_right_with_a2a(*a2a, new T(*node), true);
|
|
}
|
|
return (r>0?-1:0);
|
|
}
|
|
bool workers_cleanup = farm.isset_cleanup_workers();
|
|
std::vector<ff_node*> new_workers;
|
|
|
|
ff_comb* comb = new ff_comb(w[0], node, workers_cleanup, cleanup_node);
|
|
assert(comb);
|
|
new_workers.push_back(comb);
|
|
for(size_t i=1;i<w.size();++i) {
|
|
ff_comb* c = new ff_comb(w[i], new T(*node), workers_cleanup, true);
|
|
assert(c);
|
|
new_workers.push_back(c);
|
|
}
|
|
farm.change_workers(new_workers);
|
|
return 0;
|
|
}
|
|
template<typename T>
|
|
static inline int combine_right_with_a2a(ff_a2a& a2a, T* node, bool cleanup_node) {
|
|
const svector<ff_node*>& w= a2a.getSecondSet();
|
|
if (w[0]->isPipe()) { // NOTE: we suppose that all workers are homogeneous
|
|
if (combine_with_laststage(*reinterpret_cast<ff_pipeline*>(w[0]), node, cleanup_node)<0) return -1;
|
|
int r=0;
|
|
for(size_t i=1;i<w.size();++i) {
|
|
assert(w[i]->isPipe());
|
|
ff_pipeline* pipe = reinterpret_cast<ff_pipeline*>(w[i]);
|
|
r+=combine_with_laststage(*pipe, new T(*node), true);
|
|
}
|
|
return (r>0?-1:0);
|
|
}
|
|
std::vector<ff_node*> new_secondset;
|
|
|
|
ff_comb* comb = new ff_comb(w[0], node, false, cleanup_node);
|
|
assert(comb);
|
|
new_secondset.push_back(comb);
|
|
for(size_t i=1;i<w.size();++i) {
|
|
ff_comb* c = new ff_comb(w[i], new T(*node), false, true);
|
|
assert(c);
|
|
new_secondset.push_back(c);
|
|
}
|
|
a2a.change_secondset(new_secondset, true);
|
|
return 0;
|
|
}
|
|
template<typename T>
|
|
static inline int combine_left_with_a2a(ff_a2a& a2a, T* node, bool cleanup_node) {
|
|
const svector<ff_node*>& w= a2a.getFirstSet();
|
|
if (w[0]->isPipe()) { // NOTE: we suppose that all workers are homogeneous
|
|
|
|
if (combine_with_firststage(*reinterpret_cast<ff_pipeline*>(w[0]), node, cleanup_node)<0)
|
|
return -1;
|
|
int r=0;
|
|
for(size_t i=1;i<w.size();++i) {
|
|
assert(w[i]->isPipe());
|
|
ff_pipeline* pipe = reinterpret_cast<ff_pipeline*>(w[i]);
|
|
r+=combine_with_firststage(*pipe, new T(*node), true);
|
|
}
|
|
return (r>0?-1:0);
|
|
}
|
|
std::vector<ff_node*> new_firstset;
|
|
ff_comb* comb = new ff_comb(node, w[0], cleanup_node, false);
|
|
assert(comb);
|
|
new_firstset.push_back(comb);
|
|
for(size_t i=1;i<w.size();++i) {
|
|
ff_comb* c = new ff_comb(new T(*node), w[i], true, false);
|
|
assert(c);
|
|
new_firstset.push_back(c);
|
|
}
|
|
a2a.change_firstset(new_firstset, a2a.ondemand_buffer(), true);
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* It combines the node passed as second parameter with the last stage of the pipeline.
|
|
* The node is added at the right-hand side of the last pipeline stage.
|
|
* This transformation is logically equivalent to the following pipeline: ff_Pipe<> pipe2(pipe, node);
|
|
*/
|
|
template<typename T>
|
|
static inline int combine_with_laststage(ff_pipeline& pipe, T* node, bool cleanup_node) {
|
|
pipe.flatten();
|
|
ff_node* last = pipe.get_lastnode(); // it cannot be a pipeline
|
|
if (!last) {
|
|
error("combine_with_laststage: empty pipeline\n");
|
|
return -1;
|
|
}
|
|
if (last->isAll2All()) {
|
|
return combine_right_with_a2a(*reinterpret_cast<ff_a2a*>(last), node, cleanup_node);
|
|
}
|
|
if (last->isFarm()) {
|
|
return combine_right_with_farm(*reinterpret_cast<ff_farm*>(last), node, cleanup_node);
|
|
}
|
|
bool node_cleanup = pipe.isset_cleanup_nodes();
|
|
int nstages=static_cast<int>(pipe.nodes_list.size());
|
|
ff_comb* comb = new ff_comb(last, node, node_cleanup , cleanup_node);
|
|
pipe.remove_stage(nstages-1);
|
|
pipe.insert_stage((nstages-1)>0?(nstages-1):0, comb, true);
|
|
return 0;
|
|
}
|
|
|
|
|
|
/* This is farm specific.
|
|
* - It basically sets the threshold for enabling blocking mode.
|
|
* - It can remove the collector of internal farms in a farm of farms composition.
|
|
* - TODO: Farm of farms ---> single farm with two emitters combined (external+internal)
|
|
*/
|
|
static inline int optimize_static(ff_farm& farm, const OptLevel& opt=OptLevel1()) {
|
|
if (farm.prepared) {
|
|
error("optimize_static (farm) called after prepare\n");
|
|
return -1;
|
|
}
|
|
// optimizing internal pipelines, if any
|
|
OptLevel iopt(opt);
|
|
iopt.blocking_mode = false;
|
|
iopt.no_initial_barrier = false;
|
|
iopt.no_default_mapping = false;
|
|
const svector<ff_node*> &Workers = farm.getWorkers();
|
|
for(size_t i=0;i<Workers.size();++i) {
|
|
if (Workers[i]->isPipe()) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (farm): Looking for optimizations in the internal pipeline %ld\n",i);
|
|
|
|
ff_pipeline *ipipe = reinterpret_cast<ff_pipeline*>(Workers[i]);
|
|
if (optimize_static(*ipipe, iopt)) return -1;
|
|
}
|
|
}
|
|
|
|
// here it looks for internal farms with null collectors
|
|
if (opt.remove_collector) {
|
|
auto optimize_internal_farm = [opt](ff_farm& ifarm) {
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
iopt.verbose_level = opt.verbose_level;
|
|
if (optimize_static(ifarm, iopt)<0) return -1;
|
|
if (ifarm.getCollector() == nullptr) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (farm): REMOVE_COLLECTOR: Removed farm collector\n");
|
|
ifarm.remove_collector();
|
|
}
|
|
return 0;
|
|
};
|
|
|
|
const svector<ff_node*>& W = farm.getWorkers();
|
|
for(size_t i=0;i<W.size();++i) {
|
|
if (W[i]->isFarm() && !W[i]->isOFarm()) {
|
|
ff_farm* ifarm = reinterpret_cast<ff_farm*>(W[i]);
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (farm): Looking for optimizations in the internal farm %ld\n",i);
|
|
|
|
if (optimize_internal_farm(*ifarm)<0) return -1;
|
|
} else {
|
|
if (W[i]->isPipe()) {
|
|
ff_pipeline* ipipe = reinterpret_cast<ff_pipeline*>(W[i]);
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
iopt.verbose_level = opt.verbose_level;
|
|
if (optimize_static(*ipipe, iopt)<0) return -1;
|
|
|
|
|
|
#if 0
|
|
ff_node* last = ipipe->get_lastnode();
|
|
if (last->isFarm() && !last->isOFarm()) {
|
|
ff_farm* ifarm = reinterpret_cast<ff_farm*>(last);
|
|
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (farm): Looking for optimizations in the internal last farm of a pipeline %ld\n",i);
|
|
|
|
if (optimize_internal_farm(*ifarm)<0) return -1;
|
|
}
|
|
#endif
|
|
}
|
|
if (W[i]->isAll2All()) {
|
|
ff_a2a *a2a = reinterpret_cast<ff_a2a*>(W[i]);
|
|
const svector<ff_node*>& W1 = a2a->getFirstSet();
|
|
const svector<ff_node*>& W2 = a2a->getSecondSet();
|
|
for(size_t j=0;j<W1.size();++j) {
|
|
if (W1[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W1[j]);
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
iopt.verbose_level = opt.verbose_level;
|
|
if (optimize_static(*ipipe, iopt)<0) return -1;
|
|
}
|
|
}
|
|
for(size_t j=0;j<W2.size();++j) {
|
|
if (W2[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W2[j]);
|
|
OptLevel iopt;
|
|
iopt.remove_collector=true;
|
|
iopt.verbose_level = opt.verbose_level;
|
|
if (optimize_static(*ipipe, iopt)<0) return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// swithing to blocking mode if the n. of threads is greater than the threshold
|
|
if (opt.blocking_mode) {
|
|
ssize_t card = farm.cardinality();
|
|
if (opt.max_nb_threads < card) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (farm): BLOCKING_MODE: Activating blocking mode, threshold=%ld, number of threads=%ld\n",opt.max_nb_threads, card);
|
|
|
|
farm.blocking_mode(true);
|
|
}
|
|
}
|
|
|
|
// turning off initial/default mapping if the n. of threads is greater than the threshold
|
|
if (opt.no_default_mapping) {
|
|
ssize_t card = farm.cardinality();
|
|
if (opt.max_mapped_threads < card) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (farm): MAPPING: Disabling mapping, threshold=%ld, number of threads=%ld\n",opt.max_mapped_threads, card);
|
|
|
|
farm.no_mapping();
|
|
}
|
|
}
|
|
// no initial barrier
|
|
if (opt.no_initial_barrier) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (farm): NO_INITIAL_BARRIER: Initial barrier disabled\n");
|
|
farm.no_barrier();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
*
|
|
*/
|
|
static inline int optimize_static(ff_pipeline& pipe, const OptLevel& opt=OptLevel1()) {
|
|
if (pipe.prepared) {
|
|
error("optimize_static (pipeline) called after prepare\n");
|
|
return -1;
|
|
}
|
|
|
|
// flattening the pipeline
|
|
pipe.flatten();
|
|
int nstages=static_cast<int>(pipe.nodes_list.size());
|
|
|
|
// looking for farm and all-to-all because they might have pipeline inside
|
|
// for each nested pipeline the optimize_pipeline function is recursively
|
|
// called following a depth-first search
|
|
|
|
OptLevel iopt(opt);
|
|
iopt.blocking_mode = false;
|
|
iopt.no_initial_barrier = false;
|
|
iopt.no_default_mapping = false;
|
|
for(int i=0;i<nstages;++i) {
|
|
if (pipe.nodes_list[i]->isFarm()) {
|
|
ff_farm *farm = reinterpret_cast<ff_farm*>(pipe.nodes_list[i]);
|
|
const svector<ff_node*>& W = farm->getWorkers();
|
|
for(size_t j=0;j<W.size();++j) {
|
|
if (W[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W[j]);
|
|
if (optimize_static(*ipipe, iopt)) return -1;
|
|
}
|
|
}
|
|
} else if (pipe.nodes_list[i]->isAll2All()) {
|
|
ff_a2a *a2a = reinterpret_cast<ff_a2a*>(pipe.nodes_list[i]);
|
|
const svector<ff_node*>& W1 = a2a->getFirstSet();
|
|
const svector<ff_node*>& W2 = a2a->getSecondSet();
|
|
for(size_t j=0;j<W1.size();++j) {
|
|
if (W1[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W1[j]);
|
|
if (optimize_static(*ipipe, iopt)) return -1;
|
|
}
|
|
}
|
|
for(size_t j=0;j<W2.size();++j) {
|
|
if (W2[j]->isPipe()) {
|
|
ff_pipeline* ipipe=reinterpret_cast<ff_pipeline*>(W2[j]);
|
|
if (optimize_static(*ipipe, iopt)) return -1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ------------------ helping function ----------------------
|
|
auto find_farm_with_null_collector =
|
|
[](const svector<ff_node*>& nodeslist, int start=0)->int {
|
|
for(int i=start;i<(int)(nodeslist.size());++i) {
|
|
if (nodeslist[i]->isFarm()) {
|
|
ff_farm *farm = reinterpret_cast<ff_farm*>(nodeslist[i]);
|
|
if (farm->getCollector() == nullptr) return i;
|
|
}
|
|
}
|
|
return -1;
|
|
};
|
|
auto find_farm_with_null_emitter =
|
|
[](const svector<ff_node*>& nodeslist, int start=0)->int {
|
|
for(int i=start;i<(int)(nodeslist.size());++i) {
|
|
if (nodeslist[i]->isFarm() &&
|
|
(nullptr == (reinterpret_cast<ff_farm*>(nodeslist[i]))->getEmitter())
|
|
)
|
|
return i;
|
|
}
|
|
return -1;
|
|
};
|
|
// looking for the longest sequence of farms (or ofarms) with the same number of workers
|
|
auto farm_sequence =
|
|
[&](const svector<ff_node*>& nodeslist, int& first_farm, int& last_farm) {
|
|
bool ofarm = nodeslist[first_farm]->isOFarm();
|
|
size_t nworkers = (reinterpret_cast<ff_farm*>(nodeslist[first_farm]))->getNWorkers();
|
|
int starting_point=first_farm+1;
|
|
int first = first_farm, last = last_farm;
|
|
while (starting_point<static_cast<int>(nodeslist.size())) {
|
|
bool ok=true;
|
|
int next = find_farm_with_null_emitter(nodeslist, starting_point);
|
|
if (next == -1) break;
|
|
else {
|
|
for(int i=starting_point; i<=next;) {
|
|
if ((ofarm?nodeslist[i]->isOFarm():!nodeslist[i]->isOFarm()) &&
|
|
(nworkers == (reinterpret_cast<ff_farm*>(nodeslist[i]))->getNWorkers()) &&
|
|
(nullptr == (reinterpret_cast<ff_farm*>(nodeslist[i]))->getCollector()) &&
|
|
(nullptr == (reinterpret_cast<ff_farm*>(nodeslist[i]))->getEmitter())
|
|
)
|
|
++i;
|
|
else { ok = false; break; }
|
|
}
|
|
if (ok)
|
|
if ((reinterpret_cast<ff_farm*>(nodeslist[next]))->getEmitter() != nullptr) ok=false;
|
|
}
|
|
if (ok) {
|
|
last = next;
|
|
starting_point = next+1;
|
|
} else {
|
|
if (last==-1) {
|
|
first = find_farm_with_null_collector(nodeslist, first+1);
|
|
if (first==-1) break;
|
|
starting_point = first_farm+1;
|
|
} break;
|
|
}
|
|
}
|
|
if (first != -1 && last != -1) {
|
|
first_farm = first;
|
|
last_farm = last;
|
|
}
|
|
};
|
|
// introduces the normal-form of a sequence of farms (or ofarms)
|
|
auto combine_farm_sequence =
|
|
[](const svector<ff_node*>& nodeslist, int first_farm, int last_farm) {
|
|
|
|
svector<svector<ff_node*> > W(16);
|
|
W.resize(last_farm-first_farm+1);
|
|
for(int i=first_farm, j=0; i<=last_farm; ++i,++j) {
|
|
W[j]=reinterpret_cast<ff_farm*>(nodeslist[i])->getWorkers();
|
|
}
|
|
size_t nfarms = W.size();
|
|
size_t nworkers = W[0].size();
|
|
|
|
std::vector<ff_node*> Workers(nworkers);
|
|
for(size_t j=0; j<nworkers; ++j) {
|
|
if (nfarms==2) {
|
|
ff_comb *p = new ff_comb(W[0][j],W[1][j]);
|
|
assert(p);
|
|
Workers[j] = p;
|
|
} else {
|
|
const ff_comb *p = new ff_comb(W[0][j],W[1][j]);
|
|
for(size_t i=2;i<nfarms;++i) {
|
|
const ff_comb* combtmp = new ff_comb(*p, W[i][j]);
|
|
assert(combtmp);
|
|
delete p;
|
|
p = combtmp;
|
|
}
|
|
Workers[j] = const_cast<ff_comb*>(p);
|
|
}
|
|
}
|
|
ff_farm* firstfarm= reinterpret_cast<ff_farm*>(nodeslist[first_farm]);
|
|
ff_farm* lastfarm = reinterpret_cast<ff_farm*>(nodeslist[last_farm]);
|
|
ff_farm* newfarm = new ff_farm;
|
|
if (firstfarm->isOFarm()) {
|
|
assert(lastfarm->isOFarm());
|
|
newfarm->set_ordered();
|
|
}
|
|
|
|
if (firstfarm->getEmitter()) newfarm->add_emitter(firstfarm->getEmitter());
|
|
if (lastfarm->hasCollector())
|
|
newfarm->add_collector(lastfarm->getCollector());
|
|
newfarm->add_workers(Workers);
|
|
newfarm->cleanup_workers();
|
|
newfarm->set_scheduling_ondemand(firstfarm->ondemand_buffer());
|
|
|
|
return newfarm;
|
|
};
|
|
// ---------------- end helping function --------------------
|
|
|
|
if (opt.merge_farms) {
|
|
// find the first farm with default collector or with no collector
|
|
int first_farm = find_farm_with_null_collector(pipe.nodes_list);
|
|
if (first_farm!=-1) {
|
|
do {
|
|
int last_farm = -1;
|
|
farm_sequence(pipe.nodes_list,first_farm,last_farm);
|
|
if (first_farm<last_farm) { // normal form
|
|
ff_farm *newfarm = combine_farm_sequence(pipe.nodes_list,first_farm,last_farm);
|
|
for(int i=first_farm; i<=last_farm; ++i) pipe.remove_stage(first_farm);
|
|
pipe.insert_stage(first_farm, newfarm, true);
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (pipe): MERGE_FARMS: Merged farms staged [%d-%d]\n", first_farm, last_farm);
|
|
|
|
}
|
|
first_farm = find_farm_with_null_collector(pipe.nodes_list, first_farm+1);
|
|
}while(first_farm!=-1 && first_farm < static_cast<int>(pipe.nodes_list.size()));
|
|
}
|
|
}
|
|
if (opt.introduce_a2a) {
|
|
int first_farm = find_farm_with_null_collector(pipe.nodes_list);
|
|
while(first_farm != -1 && (first_farm < static_cast<int>(pipe.nodes_list.size()-1))) {
|
|
if (!pipe.nodes_list[first_farm]->isOFarm()) {
|
|
if (pipe.nodes_list[first_farm+1]->isFarm() && !pipe.nodes_list[first_farm+1]->isOFarm()) {
|
|
ff_farm *farm1 = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm]);
|
|
ff_farm *farm2 = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm+1]);
|
|
if (farm2->getEmitter() == nullptr) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (pipe): INTRODUCE_A2A: Introducing all-to-all between %d and %d stages\n", first_farm, first_farm+1);
|
|
const ff_farm f = combine_farms_a2a(*farm1, *farm2);
|
|
ff_farm* newfarm = new ff_farm(f);
|
|
assert(newfarm);
|
|
pipe.remove_stage(first_farm);
|
|
pipe.remove_stage(first_farm);
|
|
pipe.insert_stage(first_farm, newfarm, true);
|
|
first_farm = find_farm_with_null_collector(pipe.nodes_list, first_farm+1);
|
|
}
|
|
} else {
|
|
if (pipe.nodes_list[first_farm+1]->isOFarm())
|
|
opt_report(opt.verbose_level, OPT_INFO,
|
|
"OPT (pipe): INTRODUCE_A2A: cannot introduce A2A because node %d is an ordered farm\n", first_farm+1);
|
|
first_farm = find_farm_with_null_collector(pipe.nodes_list, first_farm+2);
|
|
}
|
|
} else {
|
|
opt_report(opt.verbose_level, OPT_INFO,
|
|
"OPT (pipe): INTRODUCE_A2A: cannot introduce A2A because node %d is an ordered farm\n", first_farm);
|
|
first_farm = find_farm_with_null_collector(pipe.nodes_list, first_farm+1);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (opt.remove_collector) {
|
|
// first, for all farms in the pipeline we try to optimize farms' workers
|
|
OptLevel farmopt;
|
|
farmopt.remove_collector = true;
|
|
farmopt.verbose_level = opt.verbose_level;
|
|
for(size_t i=0;i<pipe.nodes_list.size();++i) {
|
|
if (pipe.nodes_list[i]->isFarm()) {
|
|
ff_farm *farmnode = reinterpret_cast<ff_farm*>(pipe.nodes_list[i]);
|
|
if (optimize_static(*farmnode, farmopt)<0) {
|
|
error("optimize_static, trying to optimize the farm at stage %ld\n", i);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
int first_farm, next=0;
|
|
while((first_farm=find_farm_with_null_collector(pipe.nodes_list, next)) != -1) {
|
|
if (first_farm < static_cast<int>(pipe.nodes_list.size()-1)) {
|
|
|
|
// TODO: if the next stage is A2A would be nice to have a rule
|
|
// that attaches the farm workers with the first set of nodes
|
|
|
|
ff_farm *farm = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm]);
|
|
if (farm->hasCollector()) {
|
|
if (farm->isOFarm()) {
|
|
if ((!pipe.nodes_list[first_farm+1]->isAll2All()) &&
|
|
(!pipe.nodes_list[first_farm+1]->isFarm())) {
|
|
farm->add_collector(pipe.nodes_list[first_farm+1]);
|
|
pipe.remove_stage(first_farm+1);
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): REMOVE_COLLECTOR: Merged next stage with ordered-farm collector\n");
|
|
}
|
|
} else {
|
|
if (!pipe.nodes_list[first_farm+1]->isAll2All()) {
|
|
farm->remove_collector();
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): REMOVE_COLLECTOR: Removed farm collector\n");
|
|
|
|
if (!pipe.nodes_list[first_farm+1]->isMultiInput()) {
|
|
// the next stage is a standard node
|
|
ff_node *next = pipe.nodes_list[first_farm+1];
|
|
pipe.remove_stage(first_farm+1);
|
|
ff_minode *mi = new internal_mi_transformer(next);
|
|
assert(mi);
|
|
pipe.insert_stage(first_farm+1, mi, true);
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): REMOVE_COLLECTOR: Transformed next stage to multi-input node\n");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else { // this is the last stage (or the only stage)
|
|
ff_farm *farm = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm]);
|
|
if (!farm->isOFarm()) {
|
|
if (farm->hasCollector()) {
|
|
farm->remove_collector();
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): REMOVE_COLLECTOR: Removed farm collector\n");
|
|
}
|
|
}
|
|
}
|
|
next=first_farm+1;
|
|
}
|
|
}
|
|
if (opt.merge_with_emitter) {
|
|
int first_farm = find_farm_with_null_emitter(pipe.nodes_list);
|
|
if (first_farm!=-1) {
|
|
if (first_farm>0) { // it is not the first one
|
|
bool prev_single_standard = (!pipe.nodes_list[first_farm-1]->isMultiOutput());
|
|
if (prev_single_standard) {
|
|
// could be a farm with a collector
|
|
if (pipe.nodes_list[first_farm-1]->isFarm()) {
|
|
ff_farm *farm_prev = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm-1]);
|
|
if (farm_prev->hasCollector()) {
|
|
ff_node* collector=farm_prev->getCollector();
|
|
if (collector->isMultiInput() && !collector->isComp()) {
|
|
error("MERGING MULTI-INPUT COLLECTOR TO THE FARM EMITTER NOT YET SUPPORTED\n");
|
|
abort();
|
|
// TODO we have to create a multi-input comp to add to the emitter
|
|
}
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): MERGE_WITH_EMITTER: Merged previous stage with farm emitter\n");
|
|
ff_farm *farm = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm]);
|
|
farm->add_emitter(collector);
|
|
farm_prev->remove_collector();
|
|
}
|
|
} else {
|
|
ff_node *node = pipe.nodes_list[first_farm-1];
|
|
if (node->isMultiInput() && !node->isComp()) {
|
|
error("MERGING MULTI-INPUT NODE TO THE FARM EMITTER NOT YET SUPPORTED\n");
|
|
//TODO: we have to create a multi-input comp to add to the emitter
|
|
abort();
|
|
}
|
|
ff_farm *farm = reinterpret_cast<ff_farm*>(pipe.nodes_list[first_farm]);
|
|
if (pipe.nodes_list[first_farm]->isOFarm()) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): MERGE_WITH_EMITTER: Merged previous stage with ordered-farm emitter\n");
|
|
} else {
|
|
opt_report(opt.verbose_level, OPT_NORMAL, "OPT (pipe): MERGE_WITH_EMITTER: Merged previous stage with farm emitter\n");
|
|
}
|
|
farm->add_emitter(node);
|
|
pipe.remove_stage(first_farm-1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// activate blocking mode if the n. of threads is greater than the threshold
|
|
if (opt.blocking_mode) {
|
|
ssize_t card = pipe.cardinality();
|
|
if (opt.max_nb_threads < card) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (pipe): BLOCKING_MODE: Activating blocking mode, threshold=%ld, number of threads=%ld\n",opt.max_nb_threads, card);
|
|
pipe.blocking_mode(true);
|
|
}
|
|
}
|
|
// turning off initial/default mapping if the n. of threads is greater than the threshold
|
|
if (opt.no_default_mapping) {
|
|
ssize_t card = pipe.cardinality();
|
|
if (opt.max_mapped_threads < card) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (pipe): MAPPING: Disabling mapping, threshold=%ld, number of threads=%ld\n",opt.max_mapped_threads, card);
|
|
|
|
pipe.no_mapping();
|
|
}
|
|
}
|
|
// no initial barrier
|
|
if (opt.no_initial_barrier) {
|
|
opt_report(opt.verbose_level, OPT_NORMAL,
|
|
"OPT (pipe): NO_INITIAL_BARRIER: Initial barrier disabled\n");
|
|
pipe.no_barrier();
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
} // namespace ff
|
|
#endif /* FF_OPTIMIZE_HPP */
|