network.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2021  Music Technology Group - Universitat Pompeu Fabra
 *
 * This file is part of Essentia
 *
 * Essentia is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation (FSF), either version 3 of the License, or (at your
 * option) any later version.
 *
 * 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 General Public License for more
 * details.
 *
 * You should have received a copy of the Affero GNU General Public License
 * version 3 along with this program.  If not, see http://www.gnu.org/licenses/
 */
 
#ifndef ESSENTIA_SCHEDULER_NETWORK_H
#define ESSENTIA_SCHEDULER_NETWORK_H
 
#include <vector>
#include <set>
#include <stack>
#include "../streaming/streamingalgorithm.h"
#include "../essentiautil.h"
 
namespace essentia {
namespace streaming {
 
class AlgorithmComposite;
class SourceBase;
 
} // namespace streaming
} // namespace essentia
 
 
 
 
namespace essentia {
namespace scheduler {
 
typedef std::vector<streaming::Algorithm*> AlgoVector;
typedef std::set<streaming::Algorithm*> AlgoSet;
 
 
 
class NetworkNode {
 public:
  NetworkNode(streaming::Algorithm* algo) : _algo(algo) {}
 
  const std::vector<NetworkNode*>& children() const { return _children; }
  void setChildren(const std::vector<NetworkNode*>& children) { _children = children; }
  void addChild(NetworkNode* child) { if (!contains(_children, child)) _children.push_back(child); }
 
  const streaming::Algorithm* algorithm() const { return _algo; }
        streaming::Algorithm* algorithm()       { return _algo; }
 
  std::vector<NetworkNode*> addVisibleDependencies(std::map<streaming::Algorithm*, NetworkNode*>& algoNodeMap);
 
 protected:
  streaming::Algorithm* _algo;
  std::vector<NetworkNode*> _children;
};
 
typedef std::vector<NetworkNode*> NodeVector;
typedef std::set<NetworkNode*> NodeSet;
typedef std::stack<NetworkNode*> NodeStack;
 
 
 
class Network {
 
 public:
  Network(streaming::Algorithm* generator, bool takeOwnership = true);
 
  ~Network();
 
  void run();
 
  void runPrepare();
 
  bool runStep();
 
  void update() {
    buildVisibleNetwork();
    buildExecutionNetwork();
    topologicalSortExecutionNetwork();
  }
 
  void reset();
 
  void clear();
 
  void deleteAlgorithms();
 
 
  streaming::Algorithm* findAlgorithm(const std::string& name);
 
  NetworkNode* visibleNetworkRoot() { return _visibleNetworkRoot; }
  NetworkNode* executionNetworkRoot() {
    if (_visibleNetworkRoot && !_executionNetworkRoot) {
      buildExecutionNetwork();
    }
    return _executionNetworkRoot;
  }
 
  const std::vector<streaming::Algorithm*>& linearExecutionOrder() const { return _toposortedNetwork; }
 
 
  static std::vector<streaming::Algorithm*> innerVisibleAlgorithms(streaming::Algorithm* algo);
 
  void printBufferFillState();
 
  static Network* lastCreated;
 
 protected:
  bool _takeOwnership;
  streaming::Algorithm* _generator;
  NetworkNode* _visibleNetworkRoot;
  NetworkNode* _executionNetworkRoot;
  std::vector<streaming::Algorithm*> _toposortedNetwork;
 
  void buildVisibleNetwork();
 
  void buildExecutionNetwork();
 
  void topologicalSortExecutionNetwork();
 
  // TODO: rename AlgoSet visibleAlgos() const;
  AlgoSet _algos;
 
  void checkConnections();
 
  void checkBufferSizes();
 
  void clearVisibleNetwork();
 
  void clearExecutionNetwork();
};
 
 
void deleteNetwork(const streaming::Algorithm* algo);
 
void printNetworkBufferFillState();
 
AlgoVector computeDependencies(const streaming::Algorithm* algo);
AlgoVector computeNormalDependencies(const streaming::Algorithm* algo);
AlgoVector computeCompositeDependencies(const streaming::Algorithm* algo);
 
void cacheDependencies(streaming::Algorithm* algo);
 
AlgoSet compositeInnerAlgos(streaming::Algorithm* algo);
 
AlgoSet parentBranchInsideComposite(streaming::AlgorithmComposite* composite,
                                    streaming::Algorithm* algo);
 
} // namespace scheduler
} // namespace essentia
 
 
#endif // ESSENTIA_SCHEDULER_NETWORK_H