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

Chapter 8. openETCS Domain Framework
also a new asset of the C++11 specification. The time for putting the thread to sleep state
is calculated in Line 105 while SAMPLE_TIME is the system constant sample time T s , which is
typically in the range of milliseconds.
To synchronise all threads right from the beginning, the Lines 3 - 18 are implemented.
m_Barrier is of type ::std::condition_variable and also part of the new thread library [7,
Ch. 30] of the C++11 draft standard. Its wait(::std::mutex) method locks a calling thread
until notify_all() is executed from any other thread. It seems that this is the best that
can be implemented to avoid delays as in Figure 8.20 with the usage of soft real-time [77,
pp. 457-504] mechanisms. Since hard real-time [77, pp. 457-504] mechanisms and interfaces are
mostly platform specific, those cannot be used in the domain framework because it represents
the PIM. Hence, hard real-time mechanisms could only be integrated in the PSM.
Unfortunately, it is crucial that no thread starts its next execution before all others are
finished. Otherwise, it cannot be assured that all used CEVCTransition, CTransition, and
CLevelCondition objects are already calculated and a transition to a new CEVCState or CState
object is not ignored. Thus, before calculating the sleep time and putting the thread to sleep
in Line 111, all parallel executed threads must be synchronised. This is done by the same
construct used for the initial synchronisation (Lines 3 - 18) but extended about the evaluation
of activated transitions in Lines 46 - 101. In the case that the thread is not the last active
thread, which is determined by m_iLockedThreads == (m_Threads.size() - 1), it is simply
blocked by the m_Barrier object. In contrast to the initial synchronisation, the last thread
that enters the block not only notify all others via m_Barrier to proceed with the execution but
also checks the stack of the m_TransitionStack with the activated CEVCTransition objects of
the current cycle k. If more than one transition was activated, the one with the highest priority
is chosen and set in Line 76. A consequence is that the slowest thread or rather the thread
with the latest ending time point of its m_CurrentDataFlow[iIndex]->Execute() execution
defines the blocking / sleeping time for all others by the synchronisation. Although this can
lead to problems if a thread is severe delayed, it is necessary to guarantee that CEVCTransition
are always evaluated properly at the end of each execution k.
At the very end of the while-loop in Line 122, the start time for each thread is calculated
instead of measured as for the first execution in Line 21. This has the advantages that global
drifts in execution time are avoided and only local drifts may occur. Within a soft real-time
system, the absence of drifts cannot be guaranteed because the execution of all processes is
managed by a global scheduler that works under the regime of the operating system kernel.
Therefore, kernel processes may always block the execution of a user space process or thread
even if it has a high priority [77, pp. 457-504]. The difference between global and local drifts
are exemplary shown for one thread in Figure 8.22.
In the case of a global drift, the delay of the execution start ∆t delays all further execution
about the same ∆t because the start time is measured, which includes the delay. Even further
delays would be accumulated, so that the execution would end to be completely unsynchronised
with the desired sample time points kT s . Since the calculation of the new start time, instead
of measuring it, does not take any occurred delay ∆t into account, the next execution starts at
the correct time point 2T s for the local drift.
Of course, a general constraint to avoid drifts is that the minimal required execution time is
not bigger than the sample time: t e ≤ T s . To this property is also referred as scheduleability [77,
152