new fortune
[feisty_meow.git] / nucleus / library / processes / ethread.cpp
1 /*****************************************************************************\
2 *                                                                             *
3 *  Name   : ethread                                                           *
4 *  Author : Chris Koeritz                                                     *
5 *                                                                             *
6 *******************************************************************************
7 * Copyright (c) 1998-$now By Author.  This program is free software; you can  *
8 * redistribute it and/or modify it under the terms of the GNU General Public  *
9 * License as published by the Free Software Foundation; either version 2 of   *
10 * the License or (at your option) any later version.  This is online at:      *
11 *     http://www.fsf.org/copyleft/gpl.html                                    *
12 * Please send any updates to: fred@gruntose.com                               *
13 \*****************************************************************************/
14
15 #include "ethread.h"
16
17 #include <application/windoze_helper.h>
18 #include <basis/astring.h>
19 #include <basis/functions.h>
20 #include <basis/guards.h>
21 #include <loggers/critical_events.h>
22 #include <loggers/program_wide_logger.h>
23 #include <structures/static_memory_gremlin.h>
24 #include <timely/time_control.h>
25
26 #ifdef _MSC_VER
27   #include <process.h>
28 #elif defined(__UNIX__) || defined(__GNU_WINDOWS__)
29   #include <pthread.h>
30 #else
31   #error unknown OS for thread support.
32 #endif
33
34 using namespace basis;
35 using namespace loggers;
36 using namespace structures;
37 using namespace timely;
38
39 //#define COUNT_THREADS
40   // if this is enabled, then threads will be counted when they are created
41   // or destroyed.
42
43 #undef LOG
44 #define LOG(s) CLASS_EMERGENCY_LOG(program_wide_logger::get(), s)
45
46 namespace processes {
47
48 const int MAXIMUM_CREATE_ATTEMPTS = 20;
49   // the number of retries we allow to try creating a thread, if the first
50   // attempt fails.
51
52 const int MINIMUM_SLEEP_PERIOD = 10;
53   // this is the smallest time we'll sleep for if we're slack.
54
55 const int MAXIMUM_SLEEP_PERIOD = 200;
56   // the number of milliseconds we use for breaking up longer sleep periods.
57
58 const int SNOOZE_FOR_RETRY = 100;
59   // how long to sleep when a thread creation fails.
60
61 #ifdef COUNT_THREADS
62   // singleton thread counter code.
63   class thread_counter : public virtual root_object {
64   public:
65     thread_counter() : _count(0) {}
66     DEFINE_CLASS_NAME("thread_counter");
67     void increment() { 
68       auto_synchronizer l(_lock);
69       _count++;
70     }
71     void decrement() {
72       auto_synchronizer l(_lock);
73       _count--;
74     }
75   private:
76     int _count;
77     mutex _lock;
78   };
79
80   SAFE_STATIC(thread_counter, _current_threads, )
81
82 //hmmm: this seems to not be used anywhere yet.  it needs to be accessible
83 //      externally if it's going to serve any useful purpose.
84
85 #endif
86
87 ethread::ethread()
88 : _thread_ready(false),
89   _thread_active(false),
90   _stop_thread(false),
91   _data(NULL_POINTER),
92 #ifdef _MSC_VER
93   _handle(0),
94 #else
95   _handle(new pthread_t),
96 #endif
97   _sleep_time(0),
98   _periodic(false),
99   _next_activation(new time_stamp),
100   _how(TIGHT_INTERVAL)  // unused.
101 {
102   FUNCDEF("constructor [one-shot]");
103 }
104
105 ethread::ethread(int sleep_timer, timed_thread_types how)
106 : _thread_ready(false),
107   _thread_active(false),
108   _stop_thread(false),
109   _data(NULL_POINTER),
110 #ifdef _MSC_VER
111   _handle(0),
112 #else
113   _handle(new pthread_t),
114 #endif
115   _sleep_time(sleep_timer),
116   _periodic(true),
117   _next_activation(new time_stamp),
118   _how(how)
119 {
120   FUNCDEF("constructor [periodic]");
121   if (sleep_timer < MINIMUM_SLEEP_PERIOD) {
122     _sleep_time = MINIMUM_SLEEP_PERIOD;
123   }
124 }
125
126 ethread::~ethread()
127 {
128   stop();
129   WHACK(_next_activation);
130 #ifndef _MSC_VER
131   WHACK(_handle);
132 #endif
133 }
134
135 ///void ethread::pre_thread() {}
136
137 ///void ethread::post_thread() {}
138
139 // the reschedule operation assumes that assignment to a time stamp
140 // object (based on a real numbers) happens indivisibly.
141 void ethread::reschedule(int delay)
142 {
143   *_next_activation = time_stamp(delay);  // start after the delay.
144 }
145
146 bool ethread::start(void *thread_data)
147 {
148   FUNCDEF("start");
149   if (!thread_finished()) return false;  // already running.
150   _data = thread_data;  // store the thread's data pointer.
151   _stop_thread = false;  // don't stop now.
152   _thread_ready = true;  // we're starting it now.
153   _next_activation->reset();  // make "now" the next time to activate.
154   bool success = false;
155   int error = 0;
156   int attempts = 0;
157   while (attempts++ < MAXIMUM_CREATE_ATTEMPTS) {
158 #ifndef _MSC_VER
159     pthread_attr_t attribs;  // special flags for creation of thread.
160     int aret = pthread_attr_init(&attribs);
161     if (aret) LOG("failed to init attribs.");
162     aret = pthread_attr_setdetachstate(&attribs, PTHREAD_CREATE_DETACHED);
163     if (aret) LOG("failed to set detach state.");
164     int ret = -1;
165     if (_periodic)
166       ret = pthread_create(_handle, &attribs, periodic_thread_driver,
167           (void *)this);
168     else
169       ret = pthread_create(_handle, &attribs, one_shot_thread_driver,
170           (void *)this);
171     if (!ret) success = true;
172     else error = ret;
173 #else
174     if (_periodic)
175       _handle = _beginthread(periodic_thread_driver, 0, (void *)this);
176     else
177       _handle = _beginthread(one_shot_thread_driver, 0, (void *)this);
178     if (_handle != -1) success = true;
179     else error = critical_events::system_error();
180 #endif
181     if (success) break;  // got it created.
182     LOG("failed to create thread; trying again...");
183     time_control::sleep_ms(SNOOZE_FOR_RETRY);
184   }
185   if (!success) {
186     // couldn't start it, so reset our state.
187     LOG(astring("failed to create thread, error is ")
188         + critical_events::system_error_text(error));
189     exempt_stop();
190     return false;
191   }
192   return true;
193 }
194
195 void ethread::stop()
196 {
197   cancel();  // tell thread to leave.
198   if (!thread_started()) return;  // not running.
199   while (!thread_finished()) {
200 #ifdef _MSC_VER
201     int result = 0;
202     if (!GetExitCodeThread((HANDLE)_handle, (LPDWORD)&result)
203         || (result != STILL_ACTIVE)) {
204       exempt_stop();
205       break;
206     }
207 #endif
208     time_control::sleep_ms(10);  // wait for thread to leave.
209   }
210 }
211
212 void ethread::exempt_stop()
213 {
214   _thread_active = false;
215   _thread_ready = false;
216 #ifdef _MSC_VER
217   _handle = 0;
218 #endif
219 }
220
221 #if defined(__UNIX__) || defined(__GNU_WINDOWS__)
222 void *ethread::one_shot_thread_driver(void *hidden_pointer)
223 #elif defined(_MSC_VER)
224 void ethread::one_shot_thread_driver(void *hidden_pointer)
225 #else
226 #error unknown thread signature.
227 #endif
228 {
229   FUNCDEF("one_shot_thread_driver");
230   ethread *manager = (ethread *)hidden_pointer;
231 #ifndef _MSC_VER
232   if (!manager) return NULL_POINTER;
233 #else
234   if (!manager) return;
235 #endif
236 #ifdef COUNT_THREADS
237   _current_threads().increment();
238 #endif
239 ///  manager->pre_thread();
240   manager->_thread_active = true;
241   manager->perform_activity(manager->_data);
242 ///  manager->post_thread();
243   manager->exempt_stop();
244 #ifdef COUNT_THREADS
245   _current_threads().decrement();
246 #endif
247 #ifndef _MSC_VER
248   pthread_exit(NULL_POINTER);
249   return NULL_POINTER;
250 #else
251   _endthread();
252 #endif
253 }
254
255 #if defined(__UNIX__) || defined(__GNU_WINDOWS__)
256 void *ethread::periodic_thread_driver(void *hidden_pointer)
257 #elif defined(_MSC_VER)
258 void ethread::periodic_thread_driver(void *hidden_pointer)
259 #else
260 #error unknown thread signature.
261 #endif
262 {
263   FUNCDEF("periodic_thread_driver");
264   ethread *manager = (ethread *)hidden_pointer;
265 #if defined(__UNIX__) || defined(__GNU_WINDOWS__)
266   if (!manager) return NULL_POINTER;
267 #elif defined(_MSC_VER)
268   if (!manager) return;
269 #endif
270 #ifdef COUNT_THREADS
271   _current_threads().increment();
272 #endif
273 ///  manager->pre_thread();
274
275   while (!manager->_stop_thread) {
276     // for TIGHT_INTERVAL, we reset the next active time here.  this is safe
277     // relative to the reschedule() method, since we're about to do
278     // perform_activity() right now anyway.  this brings about a pretty hard
279     // interval; if perform_activity() takes N milliseconds, then there will
280     // only be sleep_time - N (min zero) ms before the next invocation.
281     if (manager->_how == TIGHT_INTERVAL)
282       *manager->_next_activation = time_stamp(manager->_sleep_time);
283
284     manager->_thread_active = true;
285     manager->perform_activity(manager->_data);
286     manager->_thread_active = false;
287
288     // SLACK_INTERVAL means between activations.  we reset the next activation
289     // here to ensure we wait the period specified for sleep time, including
290     // whatever time was taken for the activity itself.
291     if (manager->_how == SLACK_INTERVAL)
292       *manager->_next_activation = time_stamp(manager->_sleep_time);
293
294     // we do the sleep timing in chunks so that there's not such a huge wait
295     // when the user stops the thread before the sleep interval elapses.
296     // snooze until time for the next activation.
297     while (!manager->_stop_thread) {
298       int time_diff = int(manager->_next_activation->value()
299           - time_stamp().value());
300       if (time_diff < 0) time_diff = 0;  // time keeps on slipping.
301       // make sure we take our time if we're slack intervalled.
302       if (manager->_how == SLACK_INTERVAL) {
303         if (time_diff < MINIMUM_SLEEP_PERIOD)
304           time_diff = MINIMUM_SLEEP_PERIOD;
305       }
306       if (time_diff > MAXIMUM_SLEEP_PERIOD)
307         time_diff = MAXIMUM_SLEEP_PERIOD;
308       if (!manager->_stop_thread)
309         time_control::sleep_ms(time_diff);
310       if (time_stamp() >= *manager->_next_activation)
311         break;
312     }
313   }
314 ///  manager->post_thread();
315   manager->exempt_stop();
316 #ifdef COUNT_THREADS
317   _current_threads().decrement();
318 #endif
319 #ifndef _MSC_VER
320   pthread_exit(NULL_POINTER);
321   return NULL_POINTER;
322 #else
323   _endthread();
324 #endif
325 }
326
327 } //namespace.
328