SUMO - Simulation of Urban MObility
GUIRunThread.cpp
Go to the documentation of this file.
1 /****************************************************************************/
9 // The thread that runs the simulation
10 /****************************************************************************/
11 // SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
12 // Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
13 /****************************************************************************/
14 //
15 // This file is part of SUMO.
16 // SUMO is free software: you can redistribute it and/or modify
17 // it under the terms of the GNU General Public License as published by
18 // the Free Software Foundation, either version 3 of the License, or
19 // (at your option) any later version.
20 //
21 /****************************************************************************/
22 
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #ifdef _MSC_VER
28 #include <windows_config.h>
29 #else
30 #include <config.h>
31 #endif
32 
33 #include <cassert>
34 #include <string>
35 #include <iostream>
36 #include <algorithm>
37 
38 #include <guisim/GUINet.h>
42 #include "GUIApplicationWindow.h"
43 #include "GUIRunThread.h"
44 #include "GUIGlobals.h"
48 #include <utils/common/SysUtils.h>
53 
54 #ifndef NO_TRACI
56 #include <traci-server/lib/TraCI.h>
57 #endif
58 
59 
60 // ===========================================================================
61 // member method definitions
62 // ===========================================================================
66  : FXSingleEventThread(app, parent),
67  myNet(0), myHalting(true), myQuit(false), mySimulationInProgress(false), myOk(true), myHaveSignaledEnd(false),
68  mySimDelay(simDelay), myEventQue(eq), myEventThrow(ev) {
72 }
73 
74 
76  // the thread shall stop
77  myQuit = true;
78  deleteSim();
79  delete myErrorRetriever;
80  delete myMessageRetriever;
81  delete myWarningRetriever;
82  // wait for the thread
83  while (mySimulationInProgress || myNet != 0);
84 }
85 
86 
87 bool
89  assert(net != 0);
90  // assign new values
91  myOk = true;
92  myNet = net;
93  mySimStartTime = start;
94  mySimEndTime = end;
95  // register message callbacks
98  if (!OptionsCont::getOptions().getBool("no-warnings")) {
100  }
101  // preload the routes especially for TraCI
103  try {
104  net->setCurrentTimeStep(start);
105  net->loadRoutes();
106  } catch (ProcessError& e2) {
107  if (std::string(e2.what()) != std::string("Process Error") && std::string(e2.what()) != std::string("")) {
108  WRITE_ERROR(e2.what());
109  }
110  MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
111  myHalting = true;
112  myOk = false;
113  mySimulationInProgress = false;
114 #ifndef _DEBUG
115  } catch (...) {
116  myHalting = true;
117  myOk = false;
118  mySimulationInProgress = false;
119 #endif
120  }
122  return myOk;
123 }
124 
125 
126 FXint
128  long beg = 0;
129  long end = -1;
130  // perform an endless loop
131  while (!myQuit) {
132  // if the simulation shall be perfomed, do it
133  if (!myHalting && myNet != 0 && myOk) {
134  if (getNet().logSimulationDuration()) {
136  if (end != -1) {
137  getNet().setIdleDuration((int)(beg - end));
138  }
139  }
140  // check whether we shall stop at this step
141  myBreakpointLock.lock();
142  const bool haltAfter = find(myBreakpoints.begin(), myBreakpoints.end(), myNet->getCurrentTimeStep()) != myBreakpoints.end();
143  myBreakpointLock.unlock();
144  // do the step
145  makeStep();
146  // stop if wished
147  if (haltAfter) {
148  stop();
149  }
150  // wait if wanted
151  long wait = (long) mySimDelay.getValue();
152  if (getNet().logSimulationDuration()) {
154  getNet().setSimDuration((int)(end - beg));
155  wait -= (end - beg);
156  }
157  if (wait > 0) {
158  sleep(wait);
159  }
160  } else {
161  // sleep if the simulation is not running
162  sleep(50);
163  }
164  }
165  // delete a maybe existing simulation at the end
166  deleteSim();
167  return 0;
168 }
169 
170 
171 void
173  GUIEvent* e = 0;
174  // simulation is being perfomed
175  mySimulationInProgress = true;
176  // execute a single step
177  try {
182 
183  // inform parent that a step has been performed
184  e = new GUIEvent_SimulationStep();
185  myEventQue.add(e);
187 
188  e = 0;
190 #ifndef NO_TRACI
191  if (state == MSNet::SIMSTATE_LOADING) {
193  TraCI::getLoadArgs().clear();
194  } else if (state != MSNet::SIMSTATE_RUNNING) {
195  if (OptionsCont::getOptions().getInt("remote-port") != 0 && !TraCIServer::wasClosed()) {
196  state = MSNet::SIMSTATE_RUNNING;
197  }
198  }
199 #endif
200  switch (state) {
207  WRITE_MESSAGE("Simulation ended at time: " + time2string(myNet->getCurrentTimeStep()));
208  WRITE_MESSAGE("Reason: " + MSNet::getStateMessage(state));
210  myHaveSignaledEnd = true;
211  }
212  break;
213  default:
214  break;
215  }
216  if (e != 0) {
217  myEventQue.add(e);
219  myHalting = true;
220  }
221  // stop the execution when only a single step should have
222  // been performed
223  if (mySingle) {
224  myHalting = true;
225  }
226  // simulation step is over
227  mySimulationInProgress = false;
228  } catch (ProcessError& e2) {
229  if (std::string(e2.what()) != std::string("Process Error") && std::string(e2.what()) != std::string("")) {
230  WRITE_ERROR(e2.what());
231  }
232  MsgHandler::getErrorInstance()->inform("Quitting (on error).", false);
234  mySimulationInProgress = false;
236  myEventQue.add(e);
238  myHalting = true;
239  myOk = false;
240 #ifndef _DEBUG
241  } catch (...) {
243  mySimulationInProgress = false;
245  myEventQue.add(e);
247  myHalting = true;
248  myOk = false;
249 #endif
250  }
251 }
252 
253 
254 void
256  mySingle = false;
257  myHalting = false;
258 }
259 
260 
261 void
263  mySingle = true;
264  myHalting = false;
265 }
266 
267 
268 void
270  // report the begin when wished
271  WRITE_MESSAGE("Simulation started with time: " + time2string(mySimStartTime));
272  myOk = true;
273 }
274 
275 
276 void
278  mySingle = false;
279  myHalting = true;
280 }
281 
282 
283 bool
285  return myNet != 0;
286 }
287 
288 
289 void
291  myHalting = true;
292  // remove message callbacks
296  //
298  if (myNet != 0) {
300  }
301  while (mySimulationInProgress);
302  delete myNet;
304  myNet = 0;
308 }
309 
310 
311 GUINet&
313  return *myNet;
314 }
315 
316 
317 void
319  myHalting = true;
320  myQuit = true;
321 }
322 
323 
324 void
325 GUIRunThread::retrieveMessage(const MsgHandler::MsgType type, const std::string& msg) {
326  GUIEvent* e = new GUIEvent_Message(type, msg);
327  myEventQue.add(e);
329 }
330 
331 
332 bool
334  return myNet != 0 && myHalting;
335 }
336 
337 
338 bool
340  return myNet != 0 && (!myHalting);
341 }
342 
343 
344 bool
346  return myNet != 0 && myHalting;
347 }
348 
349 
350 
351 /****************************************************************************/
352 
Event sent when the the simulation is over.
static MsgHandler * getWarningInstance()
Returns the instance to add warnings to.
Definition: MsgHandler.cpp:67
The message is only something to show.
Definition: MsgHandler.h:62
static std::vector< std::string > & getLoadArgs()
Definition: TraCI.h:103
static MsgHandler * getErrorInstance()
Returns the instance to add errors to.
Definition: MsgHandler.cpp:76
GUIRunThread(FXApp *app, MFXInterThreadEventClient *mw, FXRealSpinDial &simDelay, MFXEventQue< GUIEvent *> &eq, FXEX::FXThreadEvent &ev)
constructor
virtual FXint run()
starts the execution
virtual void deleteSim()
virtual bool init(GUINet *net, SUMOTime start, SUMOTime end)
initialises the thread with the new simulation
void add(T what)
Definition: MFXEventQue.h:59
GUINet & getNet() const
std::string time2string(SUMOTime t)
Definition: SUMOTime.cpp:60
virtual bool simulationIsStopable() const
SUMOTime DELTA_T
Definition: SUMOTime.cpp:40
void setCurrentTimeStep(const SUMOTime step)
Sets the current simulation step (used by state loading)
Definition: MSNet.h:265
The final simulation step has been performed.
Definition: MSNet.h:105
void addRetriever(OutputDevice *retriever)
Adds a further retriever to the instance responsible for a certain msg type.
Definition: MsgHandler.cpp:157
void clear()
Clears this container.
SimulationState
Possible states of a simulation - running or stopped with different reasons.
Definition: MSNet.h:99
virtual bool simulationIsStepable() const
void setIdleDuration(int val)
Sets the duration of the last step&#39;s idle part.
Definition: GUINet.cpp:394
static void setArgs(int argc, char **argv)
Stores the command line arguments for later parsing.
Definition: OptionsIO.cpp:62
static OptionsCont & getOptions()
Retrieves the options.
Definition: OptionsCont.cpp:65
void retrieveMessage(const MsgHandler::MsgType type, const std::string &msg)
Retrieves messages from the loading module.
bool myHalting
information whether the simulation is halting (is not being executed)
Definition: GUIRunThread.h:134
bool myHaveSignaledEnd
whether the simulation already ended
Definition: GUIRunThread.h:151
The simulation does not contain further vehicles.
Definition: MSNet.h:107
An error occured during the simulation step.
Definition: MSNet.h:111
std::vector< SUMOTime > myBreakpoints
List of breakpoints.
Definition: GUIRunThread.h:166
static void cleanupOnEnd()
Removes pending handler.
Definition: MsgHandler.cpp:238
SimulationState simulationState(SUMOTime stopTime) const
Called after a simulation step, this method returns the current simulation state. ...
Definition: MSNet.cpp:534
MFXMutex mySimulationLock
Definition: GUIRunThread.h:163
static void sleep(long ms)
virtual ~GUIRunThread()
destructor
static void closeAll()
void closeSimulation(SUMOTime start)
Closes the simulation (all files, connections, etc.)
Definition: MSNet.cpp:358
SUMOTime mySimEndTime
Definition: GUIRunThread.h:131
static GUIGlObjectStorage gIDStorage
A single static instance of this class.
virtual bool simulationIsStartable() const
The connection to a client was closed by the client.
Definition: MSNet.h:109
The simulation is running.
Definition: MSNet.h:103
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:257
bool simulationAvailable() const
void removeRetriever(OutputDevice *retriever)
Removes the retriever from the handler.
Definition: MsgHandler.cpp:171
bool mySimulationInProgress
Definition: GUIRunThread.h:143
static MsgHandler * getMessageInstance()
Returns the instance to add normal messages to.
Definition: MsgHandler.cpp:58
OutputDevice * myWarningRetriever
Definition: GUIRunThread.h:155
GUINet * myNet
the loaded simulation network
Definition: GUIRunThread.h:128
#define WRITE_ERROR(msg)
Definition: MsgHandler.h:206
void unlock()
release mutex lock
Definition: MFXMutex.cpp:92
OutputDevice * myMessageRetriever
Definition: GUIRunThread.h:155
The message is a warning.
Definition: MsgHandler.h:64
void setSimDuration(int val)
Sets the duration of the last step&#39;s simulation part.
Definition: GUINet.cpp:378
Encapsulates an object&#39;s method for using it as a message retriever.
The simulation is loading.
Definition: MSNet.h:101
OutputDevice * myErrorRetriever
The instances of message retriever encapsulations Needed to be deleted from the handler later on...
Definition: GUIRunThread.h:155
void prepareDestruction()
A MSNet extended by some values for usage within the gui.
Definition: GUINet.h:89
MFXEventQue< GUIEvent * > & myEventQue
Definition: GUIRunThread.h:159
void inform(std::string msg, bool addType=true)
adds a new error to the list
Definition: MsgHandler.cpp:85
The simulation had too many teleports.
Definition: MSNet.h:113
FXdouble getValue() const
Return current value.
void lock()
lock mutex
Definition: MFXMutex.cpp:82
FXMutex myBreakpointLock
Lock for modifying the list of breakpoints.
Definition: GUIRunThread.h:169
static std::string getStateMessage(SimulationState state)
Returns the message to show if a certain state occurs.
Definition: MSNet.cpp:572
void simulationStep()
Performs a single simulation step (locking the simulation)
Definition: GUINet.cpp:226
long long int SUMOTime
Definition: TraCIDefs.h:52
virtual void begin()
static long getCurrentMillis()
Returns the current time in milliseconds.
Definition: SysUtils.cpp:46
void loadRoutes()
loads routes for the next few steps
Definition: MSNet.cpp:352
FXEX::FXThreadEvent & myEventThrow
Definition: GUIRunThread.h:161
SUMOTime mySimStartTime
the times the simulation starts and ends with
Definition: GUIRunThread.h:131
Spinner control.
#define WRITE_MESSAGE(msg)
Definition: MsgHandler.h:201
void guiSimulationStep()
Some further steps needed for gui processing.
Definition: GUINet.cpp:219
static bool wasClosed()
check whether close was requested
FXRealSpinDial & mySimDelay
Definition: GUIRunThread.h:157
The message is an error.
Definition: MsgHandler.h:66