GCC Code Coverage Report

Directory: ./
File: include/real_time_tools/thread.hpp
Date: 2022-06-29 13:58:11
Exec Total Coverage
Lines: 13 13 100.0%
Branches: 1 2 50.0%
Line Branch Exec Source
1 /**
2 * @file thread.hpp
3 * @author Maximilien Naveau (mnaveau@tue.mpg.de)
4 * license License BSD-3-Clause
5 * @copyright Copyright (c) 2019, New York University and Max Planck
6 * Gesellschaft.
7 * @date 2019-11-21
8 */
9
10 #ifndef REALTIME_THREAD_CREATION_HPP
11 #define REALTIME_THREAD_CREATION_HPP
12
13 #include <functional>
14 #include <memory>
15 #include <string>
16 #include <vector>
17
18 #ifdef XENOMAI
19 // you MAY need to happend "static" upon declaration
20 #define THREAD_FUNCTION_RETURN_TYPE void
21 #define THREAD_FUNCTION_RETURN_VALUE
22 #include <native/cond.h>
23 #include <native/mutex.h>
24 #include <native/pipe.h>
25 #include <native/sem.h>
26 #include <native/task.h>
27 #include <native/timer.h>
28 #include <rtdk.h>
29 #include <sys/mman.h>
30
31 #elif defined NON_REAL_TIME
32 #include <iostream>
33 #include <thread>
34 // you need to happend "static" upon declaration
35 #define THREAD_FUNCTION_RETURN_TYPE void*
36 #define THREAD_FUNCTION_RETURN_VALUE nullptr
37
38 #define rt_printf printf
39
40 #elif defined RT_PREEMPT
41 #include <limits.h>
42 #include <pthread.h>
43 #include <sched.h>
44 #include <stdio.h>
45 #include <stdlib.h>
46 #include <sys/mman.h>
47 #include <unistd.h>
48 // you need to happend "static" upon declaration
49 #define THREAD_FUNCTION_RETURN_TYPE void*
50 #define THREAD_FUNCTION_RETURN_VALUE nullptr
51
52 #define rt_printf printf
53
54 #endif
55
56 namespace real_time_tools
57 {
58 /**
59 * @brief This class is a data structure allowing the user to share
60 * configurations among threads. These parameter allows you to generate
61 * real threads in xenomai and rt_preempt. The same code is compatible with
62 * Mac and ubuntu but will run non-real time threads.
63 *
64 * warning : initial version, copy pasted from :
65 * https://wiki.linuxfoundation.org/realtime/documentation/howto/applications/application_base
66 * I did not study things now, so this likely needs improvement (alternative:
67 * https://rt.wiki.kernel.org/index.php/Threaded_RT-application_with_memory_locking_and_stack_handling_example)
68 * note: if failed as mlockall, run executable with sudo or be part of the
69 * real_time group or xenomai group.
70 */
71 class RealTimeThreadParameters
72 {
73 public:
74 /**
75 * @brief Construct a new RealTimeThreadParameters object
76 */
77 1 RealTimeThreadParameters()
78 1 {
79
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 keyword_ = "real_time_thread";
80 1 priority_ = 80;
81 #ifdef XENOMAI
82 // see:
83 // https://xenomai.org/documentation/xenomai-2.6/html/api/group__task.html#ga520e6fad1decc5beff58b394ff443265
84 stack_size_ = 2000000;
85 dedicated_cpu_id_ = -1;
86 priority_ = 75; // not too high to avoid competition with SL
87 #elif defined NON_REAL_TIME
88 1 stack_size_ = -1;
89 #elif defined RT_PREEMPT
90 stack_size_ = 50 * PTHREAD_STACK_MIN;
91 #endif
92 1 cpu_id_.clear();
93 1 delay_ns_ = 0;
94 1 block_memory_ = true;
95 1 cpu_dma_latency_ = 0;
96 1 }
97 /**
98 * @brief Destroy the RealTimeThreadParameters object
99 */
100 1 ~RealTimeThreadParameters()
101 1 {
102 1 }
103
104 public:
105 /**
106 * @brief Used in xenomai to define the thread id
107 */
108 std::string keyword_;
109 /**
110 * @brief Defines the thread priority from 0 to 100
111 */
112 int priority_;
113 /**
114 * @brief Define the stack size
115 */
116 int stack_size_;
117 /**
118 * @brief Define the cpu affinity. Which means on which cpu(s) the thread
119 * is going to run
120 */
121 std::vector<int> cpu_id_;
122 /**
123 * @brief indicate on which cpu the thread will run (xenomai only)
124 */
125 int dedicated_cpu_id_;
126 /**
127 * @brief @todo Unknow Xenomai parameter
128 */
129 int delay_ns_;
130 /**
131 * @brief Defines if the thread should block the memory in a "page" or if
132 * several pages can be use. Switching memory page is time consumming and
133 * a non real time operation.
134 */
135 bool block_memory_;
136
137 /**
138 * @brief Maximum desired latency of the CPU in microseconds. Set to 0 to
139 * get best real-time performance. Set to any negative value if you do not
140 * want the thread to change the CPU latency.
141 *
142 */
143 int cpu_dma_latency_;
144 };
145
146 /**
147 * @brief This class allows you to spawn thread. Its parameter are defined
148 * above.
149 */
150 class RealTimeThread
151 {
152 public:
153 /**
154 * @brief Construct a new ThreadInfo object
155 */
156 RealTimeThread();
157
158 /**
159 * @brief We do not allow copies of this object
160 */
161 RealTimeThread(const real_time_tools::RealTimeThread& other) = delete;
162
163 /**
164 * @brief Destroy the RealTimeThread object.
165 */
166 ~RealTimeThread();
167
168 /**
169 * @brief create_realtime_thread spawns a real time thread if the OS allows
170 * it.
171 * @param[in] thread_function: the executing function for the thread.
172 * @param[in] args: arguments to be passed to the thread.
173 * @return the error code.
174 */
175 #ifdef XENOMAI
176 int create_realtime_thread(void (*thread_function)(void*),
177 void* args = nullptr);
178 #else
179 int create_realtime_thread(void* (*thread_function)(void*),
180 void* args = nullptr);
181 #endif
182
183 /**
184 * @brief join join the real time thread
185 * @return the error code.
186 */
187 int join();
188
189 /**
190 * @brief block_memory block the current and futur memory pages.
191 * see
192 * https://wiki.linuxfoundation.org/realtime/documentation/howto/applications/memory#memory-locking
193 * for further explanation.
194 */
195 void block_memory();
196
197 /**
198 * @brief Paramter of the real time thread
199 */
200 RealTimeThreadParameters parameters_;
201
202 private:
203 #if defined(XENOMAI)
204 RT_TASK thread_;
205 #elif defined(NON_REAL_TIME)
206 std::unique_ptr<std::thread> thread_;
207 #elif defined(RT_PREEMPT)
208 std::unique_ptr<pthread_t> thread_;
209 #endif
210 };
211 } // namespace real_time_tools
212
213 #endif // REALTIME_THREAD_CREATION_HPP
214