ProblemComputationData.h

Go to the documentation of this file.

/* Copyright 2017-2020 CNRS-AIST JRL and CNRS-UM LIRMM */
 
#pragma once
 
#include <tvm/api.h>
#include <tvm/defs.h>
 
#include <tvm/VariableVector.h>
#include <tvm/internal/VariableCountingVector.h>
#include <tvm/scheme/internal/ProblemDefinitionEvent.h>
 
#include <queue>
#include <vector>
 
namespace tvm::scheme::internal
{
 
class TVM_DLLAPI ProblemComputationData
{
public:
  class EventQueue : public std::queue<ProblemDefinitionEvent>
  {
  public:
    using std::queue<ProblemDefinitionEvent>::queue;
 
    using std::queue<ProblemDefinitionEvent>::c;
  };
 
  virtual ~ProblemComputationData() = default;
 
  int solverId() const;
 
  bool addVariable(VariablePtr var);
  void addVariable(const VariableVector & vars);
  bool removeVariable(Variable * v);
  void removeVariable(const VariableVector & vars);
  const VariableVector & variables() const;
 
  void setVariablesToSolution();
 
  void addEvent(const ProblemDefinitionEvent & e);
  ProblemDefinitionEvent popEvent();
  bool hasEvents() const;
  const EventQueue::container_type & events() const;
  void clearEvents();
  void clearVariables();
 
protected:
  ProblemComputationData(int solverId);
  ProblemComputationData() = delete;
 
  virtual void setVariablesToSolution_(tvm::internal::VariableCountingVector & x) = 0;
 
  tvm::internal::VariableCountingVector variables_;
 
  EventQueue events_;
 
private:
  int solverId_;
};
 
inline int ProblemComputationData::solverId() const { return solverId_; }
 
inline bool ProblemComputationData::addVariable(VariablePtr var) { return variables_.add(var); }
 
inline void ProblemComputationData::addVariable(const VariableVector & vars)
{
  for(const auto & v : vars.variables())
    addVariable(v);
}
 
inline bool ProblemComputationData::removeVariable(Variable * v) { return variables_.remove(*v); }
 
inline void ProblemComputationData::removeVariable(const VariableVector & vars)
{
  for(const auto & v : vars.variables())
    removeVariable(v.get());
}
 
inline const VariableVector & ProblemComputationData::variables() const { return variables_.variables(); }
 
inline void ProblemComputationData::setVariablesToSolution() { setVariablesToSolution_(variables_); }
 
inline void ProblemComputationData::addEvent(const ProblemDefinitionEvent & e)
{
  // By default, the event will be effectively added.
  bool add = true;
 
  // If this event is a task removal, it is useless to process other events that
  // would be in the event queue for the same task. We remove those events from
  // the queue.
  if(e.type() == ProblemDefinitionEvent::Type::TaskRemoval)
  {
    for(auto it = events_.c.begin(); it != events_.c.end();)
    {
      if(it->emitter() == e.emitter() && it->type() != ProblemDefinitionEvent::Type::TaskRemoval)
      {
        // In case the addition of the same task is in the event queue: since
        // we are removing it, it is not necessary to add the removal event.
        if(it->type() == ProblemDefinitionEvent::Type::TaskAddition)
        {
          assert(add && "The task was added twice");
          add = false;
        }
        it = events_.c.erase(it);
      }
      else
      {
        ++it;
      }
    }
  }
  if(add)
  {
    events_.push(e);
  }
}
 
[[nodiscard]] inline ProblemDefinitionEvent ProblemComputationData::popEvent()
{
  assert(hasEvents());
  auto e = events_.front();
  events_.pop();
  return e;
}
 
inline bool ProblemComputationData::hasEvents() const { return !events_.empty(); }
 
inline const ProblemComputationData::EventQueue::container_type & ProblemComputationData::events() const
{ return events_.c; }
 
inline void ProblemComputationData::clearEvents() { events_ = {}; }
 
inline void ProblemComputationData::clearVariables() { variables_.clear(); }
 
inline ProblemComputationData::ProblemComputationData(int solverId) : solverId_(solverId) {}
} // namespace tvm::scheme::internal