Ph.D. - geht es zur Homepage der Informatik des Fachbereiches 3 ...

Chapter 8. openETCS Domain Framework
8.6.2. Data Flow Implementation
Most of the functionality of CFunctionBlock elements is simple to implement, like mathematical
operations, but also the implementation of braking curves is mainly a transfer of a mathematical
/ physical model to C++ code. More crucial for the correct operation of any data flow is the
execution in equidistant time points, which will be discussed here.
Section 8.4 demonstrated that the cycles are generated in the CEVCState class by an own
thread for each independent data flow. Those threads are implemented in the following method:
void CEVCStateMachine : : CEVCState : : DataFlowThread ( const unsigned int& i I n d e x ) throw ( ) ;
Since for each independent CDataFlow object an additional thread of this method is started,
iIndex determines for which CDataFlow object in m_CurrentDataFlow the thread is responsible.
In the implementation, the m_CurrentDataFlow aggregation is declared as
: : s t d : : v e c t o r < CDataFlow∗ > m_CurrentDataFlow ;
Creating threads according to C++11 is done by using the ::std::thread class [7, Ch. 30].
Hence, all data flow threads are created and started by the lines of code in Listing D.1 in
Appendix D.
These are located in the definition of the following method:
void CEVCStateMachine : : CEVCState : : S t a r t ( ) throw ( : : oETCS : : DF : : E r r o r : : CException )
Since the CEVCStateMachine::CEVCState::Start() method should be blocking and should
only return if all threads are terminated, the ::std::thread::join() method is used, which
blocks until the corresponding thread has been terminated in Listing D.2. While this is mainly
an object-oriented and platform independent way of starting a group of worker-thread, the
thread-method implementation is more complex and therefore of more interest.
The execution of the related CDataFlow object at equidistant time points must be implemented,
which is done in corresponding CEVCState method:
void CEVCStateMachine : : CEVCState : : DataFlowThread ( const unsigned int & i I n d e x ) throw ( )
Furthermore, all m_Threads must be synchronised in that way that the execution of each
thread should start for every k at the same time point t = kT s (see (7.1)). This problem is
related to real-time scheduling [77, pp. 457-504]. Although this is very difficult to realise in real
technical systems, the time difference between the execution start points should be minimised.
Figure 8.20 sketches a sample execution in the time domain for two unsynchronised threads.
Besides that the second thread always starts the execution with a delay ∆t i , those delays
also differ: ∆t 1 ≠ ∆t 2 ≠ ∆t 3 ≠ . . . . As already discussed in Section 7.6, this can lead to an
undefined behaviour of the data flows in the time domain. The ideal sample execution for two
threads is shown in Figure 8.21
The execution is implemented as a loop that calculates for each execution cycle k the
consumed time and puts the thread for the remaining time to the next execution time point
(k + 1)T s to sleep. The corresponding C++ source code can be found in Listing D.3 in
Appendix D.
At the very first execution of the while-loop, the time point of the execution start is measured
once (Line 21) by the ::std::chrono::high_resolution_clock::now() method, which is
150