icuSources/test/intltest/simplethread.cpp

   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 //-----------------------------------------------------------------------------------
 160 struct Win32ThreadImplementation
 161 {
 162     HANDLE         fHandle;
 163     unsigned int   fThreadID;
 164 };
 165
 166
 167 extern "C" unsigned int __stdcall SimpleThreadProc(void *arg)
 168 {
 169     ((SimpleThread*)arg)->run();
 170     return 0;
 171 }
 172
 173 SimpleThread::SimpleThread()
 174 :fImplementation(0)
 175 {
 176     Win32ThreadImplementation *imp = new Win32ThreadImplementation;
 177     imp->fHandle = 0;
 178     fImplementation = imp;
 179 }
 180
 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
 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
 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
 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
 276 SimpleThread::SimpleThread()
 277 {}
 278
 279 SimpleThread::~SimpleThread()
 280 {}
 281
 282 int32_t
 283 SimpleThread::start()
 284 { return 0; }
 285
 286 void
 287 SimpleThread::run()
 288 {}
 289
 290 void
 291 SimpleThread::sleep(int32_t millis)
 292 {}
 293
 294 UBool
 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
 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
 349 SimpleThread::SimpleThread()
 350 {
 351     PosixThreadImplementation *imp = new PosixThreadImplementation;
 352     imp->fRunning   = FALSE;
 353     imp->fRan       = FALSE;
 354     fImplementation = imp;
 355 }
 356
 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
 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
 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
 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:
 467     UBool  getError() { return (fErrors > 0); }
 468     UBool  getError(UnicodeString& fillinError) { fillinError = fErrorString; return (fErrors > 0); }
 469     virtual ~ThreadWithStatus(){}
 470 protected:
 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."); }
 477 private:
 478     int32_t fErrors;
 479     UnicodeString fErrorString;
 480 };
 481
 482 #endif // ICU_USE_THREADS