src/linkgraph/linkgraphschedule.h

   1 /* $Id$ */
   2
   3 /*
   4 * This file is part of OpenTTD.
   5 * 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.
   6 * 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.
   7 * 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/>.
   8 */
   9
  10 /** @file linkgraphschedule.h Declaration of link graph schedule used for cargo distribution. */
  11
  12 #ifndef LINKGRAPHSCHEDULE_H
  13 #define LINKGRAPHSCHEDULE_H
  14
  15 #include "../thread/thread.h"
  16 #include "linkgraph.h"
  17 #include <memory>
  18
  19 class LinkGraphJob;
  20
  21 /**
  22 * A handler doing "something" on a link graph component. It must not keep any
  23 * state as it is called concurrently from different threads.
  24 */
  25 class ComponentHandler {
  26 public:
  27         /**
  28         * Destroy the handler. Must be given due to virtual Run.
  29         */
  30         virtual ~ComponentHandler() {}
  31
  32         /**
  33         * Run the handler. A link graph handler must not read or write any data
  34         * outside the given component as that would create a potential desync.
  35         * @param job Link graph component to run the handler on.
  36         */
  37         virtual void Run(LinkGraphJob &job) const = 0;
  38 };
  39
  40 class LinkGraphSchedule {
  41 private:
  42         LinkGraphSchedule();
  43         ~LinkGraphSchedule();
  44         typedef std::list<LinkGraph *> GraphList;
  45         typedef std::list<std::unique_ptr<LinkGraphJob>> JobList;
  46         friend const SaveLoad *GetLinkGraphScheduleDesc();
  47
  48 protected:
  49         std::unique_ptr<ComponentHandler> handlers[6]; ///< Handlers to be run for each job.
  50         GraphList schedule;            ///< Queue for new jobs.
  51         JobList running;               ///< Currently running jobs.
  52
  53 public:
  54         /* This is a tick where not much else is happening, so a small lag might go unnoticed. */
  55         static const uint SPAWN_JOIN_TICK = 21; ///< Tick when jobs are spawned or joined every day.
  56         static LinkGraphSchedule instance;
  57
  58         static void Run(void *j);
  59         static void Clear();
  60
  61         void SpawnNext();
  62         bool IsJoinWithUnfinishedJobDue() const;
  63         void JoinNext();
  64         void SpawnAll();
  65         void ShiftDates(int interval);
  66
  67         /**
  68         * Queue a link graph for execution.
  69         * @param lg Link graph to be queued.
  70         */
  71         void Queue(LinkGraph *lg)
  72         {
  73                 assert(LinkGraph::Get(lg->index) == lg);
  74                 this->schedule.push_back(lg);
  75         }
  76
  77         /**
  78         * Remove a link graph from the execution queue.
  79         * @param lg Link graph to be removed.
  80         */
  81         void Unqueue(LinkGraph *lg) { this->schedule.remove(lg); }
  82 };
  83
  84 class LinkGraphJobGroup : public std::enable_shared_from_this<LinkGraphJobGroup> {
  85         friend LinkGraphJob;
  86
  87 private:
  88         bool joined_thread = false;              ///< True if thread has already been joined
  89         std::unique_ptr<ThreadObject> thread;    ///< Thread the job group is running in or NULL if it's running in the main thread.
  90         const std::vector<LinkGraphJob *> jobs;  ///< The set of jobs in this job set
  91
  92 private:
  93         struct constructor_token { };
  94         static void Run(void *group);
  95         void SpawnThread();
  96         void JoinThread();
  97
  98 public:
  99         LinkGraphJobGroup(constructor_token token, std::vector<LinkGraphJob *> jobs);
 100
 101         struct JobInfo {
 102                 LinkGraphJob * job;
 103                 uint cost_estimate;
 104
 105                 JobInfo(LinkGraphJob *job);
 106                 JobInfo(LinkGraphJob *job, uint cost_estimate) :
 107                         job(job), cost_estimate(cost_estimate) { }
 108         };
 109
 110         static void ExecuteJobSet(std::vector<JobInfo> jobs);
 111 };
 112
 113 #endif /* LINKGRAPHSCHEDULE_H */