SPAR/AIModule/SparAIModule/Scheduler/Scheduler.h

Go to the documentation of this file.

#pragma once
#include "../Utils/Component.h"
#include "../Utils/SafeMultiset.h"
#include "../Utils/Task.h"
#include <cassert>
#include <string>
#include <vector>
#include "timer.h"

class Scheduler
{
public:
  class InternalSchedulerTask;
  struct TaskComparator
  {
    bool operator() (const InternalSchedulerTask* task1, const InternalSchedulerTask* task2) const;
  };
  typedef SafeMultiset<InternalSchedulerTask*, TaskComparator> TaskList;

public:
  struct TaskID
  {
    TaskID()
      : m_isActive(false)
    {
    }
    TaskList::iterator m_posInMultiset;
    bool m_isActive;
  };

  class InternalSchedulerTask : public RunnableTask
  {
  public:
    InternalSchedulerTask(const Component& owner)
      : RunnableTask(owner)
    {
    }

#ifdef _DEBUG_COMPONENT
    ~InternalSchedulerTask()
    {
      m_owner.onDeleteTask(this);
    }
#endif

    bool isActive() const
    {
      return m_taskID.m_isActive;
    }

  private:
    friend class Scheduler;
    //
    // The following members are not visible to the client; they are only stored as part of the task
    // to eliminate the need to dynamically create them (to reduce the 'new' operations).
    //

    TaskID m_taskID;
    unsigned int m_priority;
    size_t m_period;
    size_t m_executionFrame;
  };

public:
  static const int MILLISECOND_PER_FRAME = 40;

  Scheduler()
    : m_tasks(TaskComparator())
  {
  }

        //~Scheduler();

  void initialize() {};

        void onFrame()
  {
    //SPAR_LOG(LogTypes::GENERAL_ERROR, "%d, %d, %d", BWAPI::Broodwar->getLatencyTime(), BWAPI::Broodwar->getLatencyFrames(), BWAPI::Broodwar->getLatencyTime() / BWAPI::Broodwar->getLatencyFrames());
    // We need a better function to evaluate the time available at each frame
    m_tasks.do_while(ExecuteTask(*this, 99999999/*(Scheduler::MILLISECOND_PER_FRAME * Spar->getTimer().timeFrequency()) / 1000*/)); 
  }

        void activate(InternalSchedulerTask* task, unsigned int priority, size_t period, size_t waitingTimeBeforeExecution)
  {
#ifdef _DEBUG_COMPONENT
    task->m_owner.onActivateTask(task);
#endif
    task->m_priority = priority;
    task->m_period = period;
    task->m_executionFrame = BWAPI::Broodwar->getFrameCount() + waitingTimeBeforeExecution;
    TaskList::iterator it = m_tasks.insert(task);
    task->m_taskID.m_posInMultiset = it;
    task->m_taskID.m_isActive = true;
  }

  void deactivate(InternalSchedulerTask* task)
  {
    if (task->m_taskID.m_isActive)
    {
#ifdef _DEBUG_COMPONENT
      task->m_owner.onDeactivateTask(task);
#endif
      task->m_taskID.m_isActive = false;
      m_tasks.erase(task->m_taskID.m_posInMultiset);
    }
  }

  static const unsigned int SCHEDULING_MEDIUM_PRIORITY = 1000;
  static const unsigned int FSM_SCHEDULING_PRIORITY = SCHEDULING_MEDIUM_PRIORITY;

#ifdef _DEBUG_COMPONENT
  template <class Function>
  Function for_each_task(Function function) const
  {
    return m_tasks.do_while(function);
  }
#endif

private:
  TaskList m_tasks;

  class ExecuteTask
  {
  public:
    ExecuteTask(Scheduler& scheduler, Timer::value_type timeLimit)
      : m_scheduler(scheduler)
      , m_timeLimit(timeLimit)
    {
    }

    TaskList::FunctionReturn operator()(TaskList::Wrapper& wrapper) const
      {
        //if(Spar->getTimer().currentTime() < m_timeLimit)
        //  return TaskList::FunctionReturn(false,true);

        InternalSchedulerTask* task = wrapper;

        if(static_cast<int>(task->m_executionFrame) > BWAPI::Broodwar->getFrameCount())
          return TaskList::FunctionReturn(false,true);
        
        const size_t period = task->m_period;

        // When running we want to allow the user to reactivate a non-periodic task
        if (period == 0)
        {
          m_scheduler.deactivate(task);
        }

        task->run();

        // At this point we have to know whether the user has deactivated explicitely the task (if it is periodic)
        
        if (period > 0)
        {
          // We do not use "task->m_taskID.m_isActive" since the user may have deactivated and restarted the task
          if (!wrapper.isDeleted())
          {
            m_scheduler.deactivate(task);

            m_scheduler.activate(task, task->m_priority, task->m_period, task->m_period);
          }
        }
        return TaskList::FunctionReturn(false,false);
      }
  protected:
    Scheduler& m_scheduler;
    Timer::value_type m_timeLimit;
  };
  friend class ExecuteTask;
};

inline bool Scheduler::TaskComparator::operator() (const InternalSchedulerTask* task1, const InternalSchedulerTask* task2) const
{
  return task1->m_executionFrame < task2->m_executionFrame
    || (task1->m_executionFrame == task2->m_executionFrame
      && task1->m_priority < task2->m_priority);
}