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)
108    SimpleThread::SimpleThread()
109    {}
110
111    SimpleThread::~SimpleThread()
112    {}
113
114    int32_t
115    SimpleThread::start()
116    { return -1; }
117
118    void
119    SimpleThread::run()
120    {}
121
122    void
123    SimpleThread::sleep(int32_t millis)
124    {}
125
126    UBool
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//-----------------------------------------------------------------------------------
160struct Win32ThreadImplementation
161{
162    HANDLE         fHandle;
163    unsigned int   fThreadID;
164};
165
166
167extern "C" unsigned int __stdcall SimpleThreadProc(void *arg)
168{
169    ((SimpleThread*)arg)->run();
170    return 0;
171}
172
173SimpleThread::SimpleThread()
174:fImplementation(0)
175{
176    Win32ThreadImplementation *imp = new Win32ThreadImplementation;
177    imp->fHandle = 0;
178    fImplementation = imp;
179}
180
181SimpleThread::~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
196int32_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
226UBool  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
258void 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
276SimpleThread::SimpleThread()
277{}
278
279SimpleThread::~SimpleThread()
280{}
281
282int32_t
283SimpleThread::start()
284{ return 0; }
285
286void
287SimpleThread::run()
288{}
289
290void
291SimpleThread::sleep(int32_t millis)
292{}
293
294UBool
295SimpleThread::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
326struct PosixThreadImplementation
327{
328    pthread_t        fThread;
329    UBool            fRunning;
330    UBool            fRan;          // True if the thread was successfully started
331};
332
333extern "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
349SimpleThread::SimpleThread()
350{
351    PosixThreadImplementation *imp = new PosixThreadImplementation;
352    imp->fRunning   = FALSE;
353    imp->fRan       = FALSE;
354    fImplementation = imp;
355}
356
357SimpleThread::~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
367int32_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
414UBool
415SimpleThread::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
428void 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.
4560 = 216; //die
457#endif
458
459//-------------------------------------------------------------------------------------------
460//
461// class ThreadWithStatus - a thread that we can check the status and error condition of
462//
463//-------------------------------------------------------------------------------------------
464class ThreadWithStatus : public SimpleThread
465{
466public:
467    UBool  getError() { return (fErrors > 0); }
468    UBool  getError(UnicodeString& fillinError) { fillinError = fErrorString; return (fErrors > 0); }
469    virtual ~ThreadWithStatus(){}
470protected:
471    ThreadWithStatus() :  fErrors(0) {}
472    void error(const UnicodeString &error) {
473        fErrors++; fErrorString = error;
474        SimpleThread::errorFunc();
475    }
476    void error() { error("An error occured."); }
477private:
478    int32_t fErrors;
479    UnicodeString fErrorString;
480};
481
482#endif // ICU_USE_THREADS
483