1 /********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1999-2013, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6
7 #if defined(hpux)
8 # ifndef _INCLUDE_POSIX_SOURCE
9 # define _INCLUDE_POSIX_SOURCE
10 # endif
11 #endif
12
13 /* Define __EXTENSIONS__ for Solaris and old friends in strict mode. */
14 #ifndef __EXTENSIONS__
15 #define __EXTENSIONS__
16 #endif
17
18 // Defines _XOPEN_SOURCE for access to POSIX functions.
19 // Must be before any other #includes.
20 #include "uposixdefs.h"
21
22 #include "simplethread.h"
23
24 #include "unicode/utypes.h"
25 #include "unicode/ustring.h"
26 #include "umutex.h"
27 #include "cmemory.h"
28 #include "cstring.h"
29 #include "uparse.h"
30 #include "unicode/resbund.h"
31 #include "unicode/udata.h"
32 #include "unicode/uloc.h"
33 #include "unicode/locid.h"
34 #include "putilimp.h"
35 #include "intltest.h"
36
37 #include <stdio.h>
38 #include <string.h>
39 #include <ctype.h> // tolower, toupper
40
41 #if U_PLATFORM_USES_ONLY_WIN32_API
42 /* Prefer native Windows APIs even if POSIX is implemented (i.e., on Cygwin). */
43 # undef POSIX
44 #elif U_PLATFORM_IMPLEMENTS_POSIX
45 # define POSIX
46 #else
47 # undef POSIX
48 #endif
49
50 /* Needed by z/OS to get usleep */
51 #if U_PLATFORM == U_PF_OS390
52 #define __DOT1 1
53 #ifndef __UU
54 # define __UU
55 #endif
56 #ifndef _XPG4_2
57 # define _XPG4_2
58 #endif
59 #include <unistd.h>
60 #endif
61
62 #if defined(POSIX)
63 #define HAVE_IMP
64
65 #if (ICU_USE_THREADS == 1)
66 #include <pthread.h>
67 #endif
68
69 #if defined(__hpux) && defined(HPUX_CMA)
70 # if defined(read) // read being defined as cma_read causes trouble with iostream::read
71 # undef read
72 # endif
73 #endif
74
75 #if U_PLATFORM == U_PF_OS390
76 #include <sys/types.h>
77 #endif
78
79 #if U_PLATFORM != U_PF_OS390
80 #include <signal.h>
81 #endif
82
83 /* Define _XPG4_2 for Solaris and friends. */
84 #ifndef _XPG4_2
85 #define _XPG4_2
86 #endif
87
88 /* Define __USE_XOPEN_EXTENDED for Linux and glibc. */
89 #ifndef __USE_XOPEN_EXTENDED
90 #define __USE_XOPEN_EXTENDED
91 #endif
92
93 /* Define _INCLUDE_XOPEN_SOURCE_EXTENDED for HP/UX (11?). */
94 #ifndef _INCLUDE_XOPEN_SOURCE_EXTENDED
95 #define _INCLUDE_XOPEN_SOURCE_EXTENDED
96 #endif
97
98 #include <unistd.h>
99
100 #endif
101 /* HPUX */
102 #ifdef sleep
103 #undef sleep
104 #endif
105
106
107 #if (ICU_USE_THREADS==0)
SimpleThread()108 SimpleThread::SimpleThread()
109 {}
110
~SimpleThread()111 SimpleThread::~SimpleThread()
112 {}
113
114 int32_t
start()115 SimpleThread::start()
116 { return -1; }
117
118 void
run()119 SimpleThread::run()
120 {}
121
122 void
sleep(int32_t millis)123 SimpleThread::sleep(int32_t millis)
124 {}
125
126 UBool
isRunning()127 SimpleThread::isRunning() {
128 return FALSE;
129 }
130 #else
131
132 #include "unicode/putil.h"
133
134 /* for mthreadtest*/
135 #include "unicode/numfmt.h"
136 #include "unicode/choicfmt.h"
137 #include "unicode/msgfmt.h"
138 #include "unicode/locid.h"
139 #include "unicode/ucol.h"
140 #include "unicode/calendar.h"
141 #include "ucaconf.h"
142
143 #if U_PLATFORM_USES_ONLY_WIN32_API
144 #define HAVE_IMP
145
146 # define VC_EXTRALEAN
147 # define WIN32_LEAN_AND_MEAN
148 # define NOUSER
149 # define NOSERVICE
150 # define NOIME
151 # define NOMCX
152 #include <windows.h>
153 #include <process.h>
154
155 //-----------------------------------------------------------------------------------
156 //
157 // class SimpleThread Windows Implementation
158 //
159 //-----------------------------------------------------------------------------------
160 struct Win32ThreadImplementation
161 {
162 HANDLE fHandle;
163 unsigned int fThreadID;
164 };
165
166
SimpleThreadProc(void * arg)167 extern "C" unsigned int __stdcall SimpleThreadProc(void *arg)
168 {
169 ((SimpleThread*)arg)->run();
170 return 0;
171 }
172
SimpleThread()173 SimpleThread::SimpleThread()
174 :fImplementation(0)
175 {
176 Win32ThreadImplementation *imp = new Win32ThreadImplementation;
177 imp->fHandle = 0;
178 fImplementation = imp;
179 }
180
~SimpleThread()181 SimpleThread::~SimpleThread()
182 {
183 // Destructor. Because we start the thread running with _beginthreadex(),
184 // we own the Windows HANDLE for the thread and must
185 // close it here.
186 Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
187 if (imp != 0) {
188 if (imp->fHandle != 0) {
189 CloseHandle(imp->fHandle);
190 imp->fHandle = 0;
191 }
192 }
193 delete (Win32ThreadImplementation*)fImplementation;
194 }
195
start()196 int32_t SimpleThread::start()
197 {
198 Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
199 if(imp->fHandle != NULL) {
200 // The thread appears to have already been started.
201 // This is probably an error on the part of our caller.
202 return -1;
203 }
204
205 imp->fHandle = (HANDLE) _beginthreadex(
206 NULL, // Security
207 0x20000, // Stack Size
208 SimpleThreadProc, // Function to Run
209 (void *)this, // Arg List
210 0, // initflag. Start running, not suspended
211 &imp->fThreadID // thraddr
212 );
213
214 if (imp->fHandle == 0) {
215 // An error occured
216 int err = errno;
217 if (err == 0) {
218 err = -1;
219 }
220 return err;
221 }
222 return 0;
223 }
224
225
isRunning()226 UBool SimpleThread::isRunning() {
227 //
228 // Test whether the thread associated with the SimpleThread object is
229 // still actually running.
230 //
231 // NOTE: on Win64 on Itanium processors, a crashes
232 // occur if the main thread of a process exits concurrently with some
233 // other thread(s) exiting. To avoid the possibility, we wait until the
234 // OS indicates that all threads have terminated, rather than waiting
235 // only until the end of the user's Run function has been reached.
236 //
237 // I don't know whether the crashes represent a Windows bug, or whether
238 // main() programs are supposed to have to wait for their threads.
239 //
240 Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
241
242 bool success;
243 DWORD threadExitCode;
244
245 if (imp->fHandle == 0) {
246 // No handle, thread must not be running.
247 return FALSE;
248 }
249 success = GetExitCodeThread(imp->fHandle, &threadExitCode) != 0;
250 if (! success) {
251 // Can't get status, thread must not be running.
252 return FALSE;
253 }
254 return (threadExitCode == STILL_ACTIVE);
255 }
256
257
sleep(int32_t millis)258 void SimpleThread::sleep(int32_t millis)
259 {
260 ::Sleep(millis);
261 }
262
263 //-----------------------------------------------------------------------------------
264 //
265 // class SimpleThread NULL Implementation
266 //
267 //-----------------------------------------------------------------------------------
268 #elif U_PLATFORM == U_PF_CLASSIC_MACOS
269
270 // since the Mac has no preemptive threading (at least on MacOS 8), only
271 // cooperative threading, threads are a no-op. We have no yield() calls
272 // anywhere in the ICU, so we are guaranteed to be thread-safe.
273
274 #define HAVE_IMP
275
SimpleThread()276 SimpleThread::SimpleThread()
277 {}
278
~SimpleThread()279 SimpleThread::~SimpleThread()
280 {}
281
282 int32_t
start()283 SimpleThread::start()
284 { return 0; }
285
286 void
run()287 SimpleThread::run()
288 {}
289
290 void
sleep(int32_t millis)291 SimpleThread::sleep(int32_t millis)
292 {}
293
294 UBool
isRunning()295 SimpleThread::isRunning() {
296 return FALSE;
297 }
298
299 #endif
300
301
302 //-----------------------------------------------------------------------------------
303 //
304 // class SimpleThread POSIX implementation
305 //
306 // A note on the POSIX vs the Windows implementations of this class..
307 // On Windows, the main thread must verify that other threads have finished
308 // before exiting, or crashes occasionally occur. (Seen on Itanium Win64 only)
309 // The function SimpleThread::isRunning() is used for this purpose.
310 //
311 // On POSIX, there is NO reliable non-blocking mechanism to determine
312 // whether a thread has exited. pthread_kill(thread, 0) almost works,
313 // but the system can recycle thread ids immediately, so seeing that a
314 // thread exists with this call could mean that the original thread has
315 // finished and a new one started with the same ID. Useless.
316 //
317 // So we need to do the check with user code, by setting a flag just before
318 // the thread function returns. A technique that is guaranteed to fail
319 // on Windows, because it indicates that the thread is done before all
320 // system level cleanup has happened.
321 //
322 //-----------------------------------------------------------------------------------
323 #if defined(POSIX)
324 #define HAVE_IMP
325
326 struct PosixThreadImplementation
327 {
328 pthread_t fThread;
329 UBool fRunning;
330 UBool fRan; // True if the thread was successfully started
331 };
332
SimpleThreadProc(void * arg)333 extern "C" void* SimpleThreadProc(void *arg)
334 {
335 // This is the code that is run in the new separate thread.
336 SimpleThread *This = (SimpleThread *)arg;
337 This->run(); // Run the user code.
338
339 // The user function has returned. Set the flag indicating that this thread
340 // is done. Need a mutex for memory barrier purposes only, so that other thread
341 // will reliably see that the flag has changed.
342 PosixThreadImplementation *imp = (PosixThreadImplementation*)This->fImplementation;
343 umtx_lock(NULL);
344 imp->fRunning = FALSE;
345 umtx_unlock(NULL);
346 return 0;
347 }
348
SimpleThread()349 SimpleThread::SimpleThread()
350 {
351 PosixThreadImplementation *imp = new PosixThreadImplementation;
352 imp->fRunning = FALSE;
353 imp->fRan = FALSE;
354 fImplementation = imp;
355 }
356
~SimpleThread()357 SimpleThread::~SimpleThread()
358 {
359 PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
360 if (imp->fRan) {
361 pthread_join(imp->fThread, NULL);
362 }
363 delete imp;
364 fImplementation = (void *)0xdeadbeef;
365 }
366
start()367 int32_t SimpleThread::start()
368 {
369 int32_t rc;
370 static pthread_attr_t attr;
371 static UBool attrIsInitialized = FALSE;
372
373 PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
374 imp->fRunning = TRUE;
375 imp->fRan = TRUE;
376
377 #ifdef HPUX_CMA
378 if (attrIsInitialized == FALSE) {
379 rc = pthread_attr_create(&attr);
380 attrIsInitialized = TRUE;
381 }
382 rc = pthread_create(&(imp->fThread),attr,&SimpleThreadProc,(void*)this);
383 #else
384 if (attrIsInitialized == FALSE) {
385 rc = pthread_attr_init(&attr);
386 #if U_PLATFORM == U_PF_OS390
387 {
388 int detachstate = 0; // jdc30: detach state of zero causes
389 //threads created with this attr to be in
390 //an undetached state. An undetached
391 //thread will keep its resources after
392 //termination.
393 pthread_attr_setdetachstate(&attr, &detachstate);
394 }
395 #else
396 // pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
397 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
398 #endif
399 attrIsInitialized = TRUE;
400 }
401 rc = pthread_create(&(imp->fThread),&attr,&SimpleThreadProc,(void*)this);
402 #endif
403
404 if (rc != 0) {
405 // some kind of error occured, the thread did not start.
406 imp->fRan = FALSE;
407 imp->fRunning = FALSE;
408 }
409
410 return rc;
411 }
412
413
414 UBool
isRunning()415 SimpleThread::isRunning() {
416 // Note: Mutex functions are used here not for synchronization,
417 // but to force memory barriors to exist, to ensure that one thread
418 // can see changes made by another when running on processors
419 // with memory models having weak coherency.
420 PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
421 umtx_lock(NULL);
422 UBool retVal = imp->fRunning;
423 umtx_unlock(NULL);
424 return retVal;
425 }
426
427
sleep(int32_t millis)428 void SimpleThread::sleep(int32_t millis)
429 {
430 #if U_PLATFORM == U_PF_SOLARIS
431 sigignore(SIGALRM);
432 #endif
433
434 #ifdef HPUX_CMA
435 cma_sleep(millis/100);
436 #elif U_PLATFORM == U_PF_HPUX || U_PLATFORM == U_PF_OS390
437 millis *= 1000;
438 while(millis >= 1000000) {
439 usleep(999999);
440 millis -= 1000000;
441 }
442 if(millis > 0) {
443 usleep(millis);
444 }
445 #else
446 usleep(millis * 1000);
447 #endif
448 }
449
450 #endif
451 // end POSIX
452
453
454 #ifndef HAVE_IMP
455 #error No implementation for threads! Cannot test.
456 0 = 216; //die
457 #endif
458
459 //-------------------------------------------------------------------------------------------
460 //
461 // class ThreadWithStatus - a thread that we can check the status and error condition of
462 //
463 //-------------------------------------------------------------------------------------------
464 class ThreadWithStatus : public SimpleThread
465 {
466 public:
getError()467 UBool getError() { return (fErrors > 0); }
getError(UnicodeString & fillinError)468 UBool getError(UnicodeString& fillinError) { fillinError = fErrorString; return (fErrors > 0); }
~ThreadWithStatus()469 virtual ~ThreadWithStatus(){}
470 protected:
ThreadWithStatus()471 ThreadWithStatus() : fErrors(0) {}
error(const UnicodeString & error)472 void error(const UnicodeString &error) {
473 fErrors++; fErrorString = error;
474 SimpleThread::errorFunc();
475 }
error()476 void error() { error("An error occured."); }
477 private:
478 int32_t fErrors;
479 UnicodeString fErrorString;
480 };
481
482 #endif // ICU_USE_THREADS
483