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