icuSources/test/intltest/simplethread.cpp

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