linkgraphschedule.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
 * OpenTTD 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 GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "../stdafx.h"
#include "linkgraphschedule.h"
#include "init.h"
#include "demands.h"
#include "mcf.h"
#include "flowmapper.h"
#include "../framerate_type.h"
#include "../command_func.h"
#include "../network/network.h"
#include "../misc_cmd.h"
 
#include "../safeguards.h"
 
/* static */ LinkGraphSchedule LinkGraphSchedule::instance;
 
void LinkGraphSchedule::SpawnNext()
{
  if (this->schedule.empty()) return;
  LinkGraph *next = this->schedule.front();
  LinkGraph *first = next;
  while (next->Size() < 2) {
    this->schedule.splice(this->schedule.end(), this->schedule, this->schedule.begin());
    next = this->schedule.front();
    if (next == first) return;
  }
  assert(next == LinkGraph::Get(next->index));
  this->schedule.pop_front();
  if (LinkGraphJob::CanAllocateItem()) {
    LinkGraphJob *job = new LinkGraphJob(*next);
    job->SpawnThread();
    this->running.push_back(job);
  } else {
    NOT_REACHED();
  }
}
 
bool LinkGraphSchedule::IsJoinWithUnfinishedJobDue() const
{
  if (this->running.empty()) return false;
  const LinkGraphJob *next = this->running.front();
  return next->IsScheduledToBeJoined() && !next->IsJobCompleted();
}
 
void LinkGraphSchedule::JoinNext()
{
  if (this->running.empty()) return;
  LinkGraphJob *next = this->running.front();
  if (!next->IsScheduledToBeJoined()) return;
  this->running.pop_front();
  LinkGraphID id = next->LinkGraphIndex();
  delete next; // implicitly joins the thread
  if (LinkGraph::IsValidID(id)) {
    LinkGraph *lg = LinkGraph::Get(id);
    this->Unqueue(lg); // Unqueue to avoid double-queueing recycled IDs.
    this->Queue(lg);
  }
}
 
/* static */ void LinkGraphSchedule::Run(LinkGraphJob *job)
{
  for (const auto &handler : instance.handlers) {
    if (job->IsJobAborted()) return;
    handler->Run(*job);
  }
 
  /*
   * Readers of this variable in another thread may see an out of date value.
   * However this is OK as this will only happen just as a job is completing,
   * and the real synchronisation is provided by the thread join operation.
   * In the worst case the main thread will be paused for longer than
   * strictly necessary before joining.
   * This is just a hint variable to avoid performing the join excessively
   * early and blocking the main thread.
   */
 
  job->job_completed.store(true, std::memory_order_release);
}
 
void LinkGraphSchedule::SpawnAll()
{
  for (auto &it : this->running) {
    it->SpawnThread();
  }
}
 
/* static */ void LinkGraphSchedule::Clear()
{
  for (auto &it : instance.running) {
    it->AbortJob();
  }
  instance.running.clear();
  instance.schedule.clear();
}
 
void LinkGraphSchedule::ShiftDates(TimerGameEconomy::Date interval)
{
  for (LinkGraph *lg : LinkGraph::Iterate()) lg->ShiftDates(interval);
  for (LinkGraphJob *lgj : LinkGraphJob::Iterate()) lgj->ShiftJoinDate(interval);
}
 
LinkGraphSchedule::LinkGraphSchedule()
{
  this->handlers[0] = new InitHandler;
  this->handlers[1] = new DemandHandler;
  this->handlers[2] = new MCFHandler<MCF1stPass>;
  this->handlers[3] = new FlowMapper(false);
  this->handlers[4] = new MCFHandler<MCF2ndPass>;
  this->handlers[5] = new FlowMapper(true);
}
 
LinkGraphSchedule::~LinkGraphSchedule()
{
  this->Clear();
  for (const auto &handler : this->handlers) {
    delete handler;
  }
}
 
void StateGameLoop_LinkGraphPauseControl()
{
  if (_pause_mode & PM_PAUSED_LINK_GRAPH) {
    /* We are paused waiting on a job, check the job every tick. */
    if (!LinkGraphSchedule::instance.IsJoinWithUnfinishedJobDue()) {
      Command<CMD_PAUSE>::Post(PM_PAUSED_LINK_GRAPH, false);
    }
  } else if (_pause_mode == PM_UNPAUSED &&
      TimerGameEconomy::date_fract == LinkGraphSchedule::SPAWN_JOIN_TICK - 2 &&
      TimerGameEconomy::date.base() % (_settings_game.linkgraph.recalc_interval / EconomyTime::SECONDS_PER_DAY) == (_settings_game.linkgraph.recalc_interval / EconomyTime::SECONDS_PER_DAY) / 2 &&
      LinkGraphSchedule::instance.IsJoinWithUnfinishedJobDue()) {
    /* Perform check two TimerGameEconomy::date_fract ticks before we would join, to make
     * sure it also works in multiplayer. */
    Command<CMD_PAUSE>::Post(PM_PAUSED_LINK_GRAPH, true);
  }
}
 
void AfterLoad_LinkGraphPauseControl()
{
  if (LinkGraphSchedule::instance.IsJoinWithUnfinishedJobDue()) {
    _pause_mode |= PM_PAUSED_LINK_GRAPH;
  }
}
 
void OnTick_LinkGraph()
{
  if (TimerGameEconomy::date_fract != LinkGraphSchedule::SPAWN_JOIN_TICK) return;
  TimerGameEconomy::Date offset = TimerGameEconomy::date.base() % (_settings_game.linkgraph.recalc_interval / EconomyTime::SECONDS_PER_DAY);
  if (offset == 0) {
    LinkGraphSchedule::instance.SpawnNext();
  } else if (offset == (_settings_game.linkgraph.recalc_interval / EconomyTime::SECONDS_PER_DAY) / 2) {
    if (!_networking || _network_server) {
      PerformanceMeasurer::SetInactive(PFE_GL_LINKGRAPH);
      LinkGraphSchedule::instance.JoinNext();
    } else {
      PerformanceMeasurer framerate(PFE_GL_LINKGRAPH);
      LinkGraphSchedule::instance.JoinNext();
    }
  }
}