Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00012 #include "../stdafx.h"
00013 #include "../core/pool_func.hpp"
00014 #include "../window_func.h"
00015 #include "linkgraphjob.h"
00016 #include "linkgraphschedule.h"
00017
00018
00019 LinkGraphJobPool _link_graph_job_pool("LinkGraphJob");
00020 INSTANTIATE_POOL_METHODS(LinkGraphJob)
00021
00022
00028 LinkGraphJob::LinkGraphJob(const LinkGraph &orig) :
00029
00030
00031 link_graph(orig),
00032 settings(_settings_game.linkgraph),
00033 thread(NULL),
00034 join_date(_date + _settings_game.linkgraph.recalc_time)
00035 {
00036 }
00037
00042 void LinkGraphJob::EraseFlows(NodeID from)
00043 {
00044 for (NodeID node_id = 0; node_id < this->Size(); ++node_id) {
00045 (*this)[node_id].Flows().erase(from);
00046 }
00047 }
00048
00053 void LinkGraphJob::SpawnThread()
00054 {
00055 if (!ThreadObject::New(&(LinkGraphSchedule::Run), this, &this->thread)) {
00056 this->thread = NULL;
00057
00058
00059
00060
00061
00062
00063
00064 LinkGraphSchedule::Run(this);
00065 }
00066 }
00067
00071 void LinkGraphJob::JoinThread()
00072 {
00073 if (this->thread != NULL) {
00074 this->thread->Join();
00075 delete this->thread;
00076 this->thread = NULL;
00077 }
00078 }
00079
00083 LinkGraphJob::~LinkGraphJob()
00084 {
00085 this->JoinThread();
00086
00087
00088
00089 if (CleaningPool()) return;
00090
00091
00092 if (!LinkGraph::IsValidID(this->link_graph.index)) return;
00093
00094 uint size = this->Size();
00095 for (NodeID node_id = 0; node_id < size; ++node_id) {
00096 Node from = (*this)[node_id];
00097
00098
00099 Station *st = Station::GetIfValid(from.Station());
00100 if (st == NULL) {
00101 this->EraseFlows(node_id);
00102 continue;
00103 }
00104
00105
00106
00107 GoodsEntry &ge = st->goods[this->Cargo()];
00108 if (ge.link_graph != this->link_graph.index || ge.node != node_id) {
00109 this->EraseFlows(node_id);
00110 continue;
00111 }
00112
00113 LinkGraph *lg = LinkGraph::Get(ge.link_graph);
00114 FlowStatMap &flows = from.Flows();
00115
00116 for (EdgeIterator it(from.Begin()); it != from.End(); ++it) {
00117 if (from[it->first].Flow() == 0) continue;
00118 StationID to = (*this)[it->first].Station();
00119 Station *st2 = Station::GetIfValid(to);
00120 if (st2 == NULL || st2->goods[this->Cargo()].link_graph != this->link_graph.index ||
00121 st2->goods[this->Cargo()].node != it->first ||
00122 (*lg)[node_id][it->first].LastUpdate() == INVALID_DATE) {
00123
00124 StationIDStack erased = flows.DeleteFlows(to);
00125
00126
00127
00128 while (!erased.IsEmpty()) ge.flows.erase(erased.Pop());
00129 } else if ((*lg)[node_id][it->first].LastUnrestrictedUpdate() == INVALID_DATE) {
00130
00131 flows.RestrictFlows(to);
00132 }
00133 }
00134
00135
00136
00137
00138
00139 for (FlowStatMap::iterator it(ge.flows.begin()); it != ge.flows.end();) {
00140 FlowStatMap::iterator new_it = flows.find(it->first);
00141 if (new_it == flows.end()) {
00142 if (_settings_game.linkgraph.GetDistributionType(this->Cargo()) != DT_MANUAL) {
00143 it->second.Invalidate();
00144 ++it;
00145 } else {
00146 FlowStat shares(INVALID_STATION, 1);
00147 it->second.SwapShares(shares);
00148 ge.flows.erase(it++);
00149 for (FlowStat::SharesMap::const_iterator shares_it(shares.GetShares()->begin());
00150 shares_it != shares.GetShares()->end(); ++shares_it) {
00151 RerouteCargo(st, this->Cargo(), shares_it->second, st->index);
00152 }
00153 }
00154 } else {
00155 it->second.SwapShares(new_it->second);
00156 flows.erase(new_it);
00157 ++it;
00158 }
00159 }
00160 ge.flows.insert(flows.begin(), flows.end());
00161 InvalidateWindowData(WC_STATION_VIEW, st->index, this->Cargo());
00162 }
00163 }
00164
00170 void LinkGraphJob::Init()
00171 {
00172 uint size = this->Size();
00173 this->nodes.Resize(size);
00174 this->edges.Resize(size, size);
00175 for (uint i = 0; i < size; ++i) {
00176 this->nodes[i].Init(this->link_graph[i].Supply());
00177 EdgeAnnotation *node_edges = this->edges[i];
00178 for (uint j = 0; j < size; ++j) {
00179 node_edges[j].Init();
00180 }
00181 }
00182 }
00183
00187 void LinkGraphJob::EdgeAnnotation::Init()
00188 {
00189 this->demand = 0;
00190 this->flow = 0;
00191 this->unsatisfied_demand = 0;
00192 }
00193
00199 void LinkGraphJob::NodeAnnotation::Init(uint supply)
00200 {
00201 this->undelivered_supply = supply;
00202 new (&this->flows) FlowStatMap;
00203 new (&this->paths) PathList;
00204 }
00205
00214 void Path::Fork(Path *base, uint cap, int free_cap, uint dist)
00215 {
00216 this->capacity = min(base->capacity, cap);
00217 this->free_capacity = min(base->free_capacity, free_cap);
00218 this->distance = base->distance + dist;
00219 assert(this->distance > 0);
00220 if (this->parent != base) {
00221 this->Detach();
00222 this->parent = base;
00223 this->parent->num_children++;
00224 }
00225 this->origin = base->origin;
00226 }
00227
00236 uint Path::AddFlow(uint new_flow, LinkGraphJob &job, uint max_saturation)
00237 {
00238 if (this->parent != NULL) {
00239 LinkGraphJob::Edge edge = job[this->parent->node][this->node];
00240 if (max_saturation != UINT_MAX) {
00241 uint usable_cap = edge.Capacity() * max_saturation / 100;
00242 if (usable_cap > edge.Flow()) {
00243 new_flow = min(new_flow, usable_cap - edge.Flow());
00244 } else {
00245 return 0;
00246 }
00247 }
00248 new_flow = this->parent->AddFlow(new_flow, job, max_saturation);
00249 if (this->flow == 0 && new_flow > 0) {
00250 job[this->parent->node].Paths().push_front(this);
00251 }
00252 edge.AddFlow(new_flow);
00253 }
00254 this->flow += new_flow;
00255 return new_flow;
00256 }
00257
00263 Path::Path(NodeID n, bool source) :
00264 distance(source ? 0 : UINT_MAX),
00265 capacity(source ? UINT_MAX : 0),
00266 free_capacity(source ? INT_MAX : INT_MIN),
00267 flow(0), node(n), origin(source ? n : INVALID_NODE),
00268 num_children(0), parent(NULL)
00269 {}
00270