ControlProblem.h

Go to the documentation of this file.

 
#pragma once
 
#include <tvm/Task.h>
#include <tvm/graph/CallGraph.h>
#include <tvm/requirements/SolvingRequirements.h>
#include <tvm/scheme/internal/ProblemComputationData.h>
#include <tvm/scheme/internal/ProblemDefinitionEvent.h>
#include <tvm/scheme/internal/ResolutionSchemeBase.h>
#include <tvm/scheme/internal/helpers.h>
#include <tvm/task_dynamics/None.h>
#include <tvm/task_dynamics/abstract/TaskDynamics.h>
#include <tvm/utils/ProtoTask.h>
 
#include <memory>
#include <vector>
 
namespace tvm
{
class TVM_DLLAPI TaskWithRequirements : public tvm::internal::ObjWithId
{
public:
  TaskWithRequirements(const Task & task, requirements::SolvingRequirements req);
 
  Task task;
  requirements::SolvingRequirementsWithCallbacks requirements;
};
 
using TaskWithRequirementsPtr = std::shared_ptr<TaskWithRequirements>;
 
class TVM_DLLAPI ControlProblem
{
  friend class LinearizedControlProblem;
 
public:
  ControlProblem() = default;
  ControlProblem(const ControlProblem &) = delete;
  ControlProblem & operator=(const ControlProblem &) = delete;
 
  TaskWithRequirementsPtr add(const Task & task, const requirements::SolvingRequirements & req = {});
  template<constraint::Type T>
  TaskWithRequirementsPtr add(utils::ProtoTask<T> proto,
                              const task_dynamics::abstract::TaskDynamics & td,
                              const requirements::SolvingRequirements & req = {});
  template<constraint::Type T>
  TaskWithRequirementsPtr add(utils::LinearProtoTask<T> proto,
                              const task_dynamics::abstract::TaskDynamics & td,
                              const requirements::SolvingRequirements & req = {});
  template<constraint::Type T>
  TaskWithRequirementsPtr add(utils::LinearProtoTask<T> proto, const requirements::SolvingRequirements & req = {});
  void add(TaskWithRequirementsPtr tr);
  void remove(const TaskWithRequirements & tr);
  const std::vector<TaskWithRequirementsPtr> & tasks() const;
 
  int size() const;
 
  void update();
 
  void finalize();
 
  const graph::CallGraph & updateGraph() const;
 
protected:
  class Updater
  {
  public:
    Updater();
 
    template<typename T, typename... Args>
    void addInput(std::shared_ptr<T> source, Args... args);
    template<typename T>
    void removeInput(T * source);
 
    void refresh();
    void run();
 
    const graph::CallGraph & updateGraph() const;
 
  private:
    bool upToDate_;
    std::shared_ptr<graph::internal::Inputs> inputs_;
    graph::CallGraph updateGraph_;
  };
 
  virtual void update_() {}
  virtual void finalize_() {}
 
  void needFinalize();
  void notify(const scheme::internal::ProblemDefinitionEvent & e);
 
  Updater updater_;
 
private:
  void addCallBackToTask(TaskWithRequirementsPtr tr);
 
  // Note: we want to keep the tasks in the order they were introduced, mostly
  // for human understanding and debugging purposes, so that we take a
  // std::vector.
  // If this induces too much overhead when adding/removing a constraint, then
  // we should consider std::set.
  std::vector<TaskWithRequirementsPtr> tr_;
 
  // Tokens to identify and keep callbacks alive
  tvm::utils::internal::map<TaskWithRequirements const *, std::vector<internal::PairElementToken>> callbackTokens_;
 
  // Computation data for the resolution schemes
  std::map<scheme::identifier, std::unique_ptr<scheme::internal::ProblemComputationData>> computationData_;
 
  bool finalized_ = false;
 
  template<typename Problem, typename Scheme>
  friend scheme::internal::ProblemComputationData * scheme::internal::getComputationData(
      Problem & problem,
      const Scheme & resolutionScheme);
};
 
template<constraint::Type T>
TaskWithRequirementsPtr ControlProblem::add(utils::ProtoTask<T> proto,
                                            const task_dynamics::abstract::TaskDynamics & td,
                                            const requirements::SolvingRequirements & req)
{ return add({proto, td}, req); }
 
template<constraint::Type T>
TaskWithRequirementsPtr ControlProblem::add(utils::LinearProtoTask<T> proto,
                                            const task_dynamics::abstract::TaskDynamics & td,
                                            const requirements::SolvingRequirements & req)
{ return add({proto, td}, req); }
 
template<constraint::Type T>
TaskWithRequirementsPtr ControlProblem::add(utils::LinearProtoTask<T> proto,
                                            const requirements::SolvingRequirements & req)
{ return add({proto, task_dynamics::None()}, req); }
 
template<typename T, typename... Args>
inline void ControlProblem::Updater::addInput(std::shared_ptr<T> source, Args... args)
{
  inputs_->addInput(source, args...);
  upToDate_ = false;
}
 
template<typename T>
inline void ControlProblem::Updater::removeInput(T * source)
{
  inputs_->removeInput(source);
  upToDate_ = false;
}
} // namespace tvm