organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-05 13:35:32 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 12

ICU-11643 Several threading test cleanups.

Browse source 
X-SVN-Rev: 37395
This commit is contained in:
Andy Heninger 2015-04-23 23:59:24 +00:00
parent 673942389f
commit 4651204fb5
5 changed files with 268 additions and 871 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
icu4c/source/test/intltest/intltest.cpp
View file

@ -561,6 +561,7 @@ void IntlTest::setCaller( IntlTest* callingTest )
verbose = caller->verbose;
no_err_msg = caller->no_err_msg;
quick = caller->quick;
threadCount = caller->threadCount;
testoutfp = caller->testoutfp;
LL_indentlevel = caller->LL_indentlevel + indentLevel_offset;
numProps = caller->numProps;

214
icu4c/source/test/intltest/simplethread.cpp
View file

@ -1,6 +1,6 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1999-2013, International Business Machines Corporation and
* Copyright (c) 1999-2015, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
@ -62,15 +62,7 @@
#if defined(POSIX)
#define HAVE_IMP
#if (ICU_USE_THREADS == 1)
#include <pthread.h>
#endif
#if defined(__hpux) && defined(HPUX_CMA)
# if defined(read) // read being defined as cma_read causes trouble with iostream::read
# undef read
# endif
#endif
#if U_PLATFORM == U_PF_OS390
#include <sys/types.h>
@ -104,31 +96,6 @@
#endif
#if (ICU_USE_THREADS==0)
SimpleThread::SimpleThread()
{}
SimpleThread::~SimpleThread()
{}
int32_t
SimpleThread::start()
{ return -1; }
void
SimpleThread::run()
{}
void
SimpleThread::sleep(int32_t millis)
{}
UBool
SimpleThread::isRunning() {
return FALSE;
}
#else
#include "unicode/putil.h"
/* for mthreadtest*/
@ -223,77 +190,13 @@ int32_t SimpleThread::start()
}
UBool SimpleThread::isRunning() {
//
// Test whether the thread associated with the SimpleThread object is
// still actually running.
//
// NOTE: on Win64 on Itanium processors, a crashes
// occur if the main thread of a process exits concurrently with some
// other thread(s) exiting. To avoid the possibility, we wait until the
// OS indicates that all threads have terminated, rather than waiting
// only until the end of the user's Run function has been reached.
//
// I don't know whether the crashes represent a Windows bug, or whether
// main() programs are supposed to have to wait for their threads.
//
void SimpleThread::join() {
Win32ThreadImplementation *imp = (Win32ThreadImplementation*)fImplementation;
bool success;
DWORD threadExitCode;
if (imp->fHandle == 0) {
// No handle, thread must not be running.
return FALSE;
return;
}
success = GetExitCodeThread(imp->fHandle, &threadExitCode) != 0;
if (! success) {
// Can't get status, thread must not be running.
return FALSE;
}
return (threadExitCode == STILL_ACTIVE);
}
void SimpleThread::sleep(int32_t millis)
{
::Sleep(millis);
}
//-----------------------------------------------------------------------------------
//
// class SimpleThread NULL Implementation
//
//-----------------------------------------------------------------------------------
#elif U_PLATFORM == U_PF_CLASSIC_MACOS
// since the Mac has no preemptive threading (at least on MacOS 8), only
// cooperative threading, threads are a no-op. We have no yield() calls
// anywhere in the ICU, so we are guaranteed to be thread-safe.
#define HAVE_IMP
SimpleThread::SimpleThread()
{}
SimpleThread::~SimpleThread()
{}
int32_t
SimpleThread::start()
{ return 0; }
void
SimpleThread::run()
{}
void
SimpleThread::sleep(int32_t millis)
{}
UBool
SimpleThread::isRunning() {
return FALSE;
WaitForSingleObject(imp->fHandle, INFINITE);
}
#endif
@ -303,22 +206,6 @@ SimpleThread::isRunning() {
//
// class SimpleThread POSIX implementation
//
// A note on the POSIX vs the Windows implementations of this class..
// On Windows, the main thread must verify that other threads have finished
// before exiting, or crashes occasionally occur. (Seen on Itanium Win64 only)
// The function SimpleThread::isRunning() is used for this purpose.
//
// On POSIX, there is NO reliable non-blocking mechanism to determine
// whether a thread has exited. pthread_kill(thread, 0) almost works,
// but the system can recycle thread ids immediately, so seeing that a
// thread exists with this call could mean that the original thread has
// finished and a new one started with the same ID. Useless.
//
// So we need to do the check with user code, by setting a flag just before
// the thread function returns. A technique that is guaranteed to fail
// on Windows, because it indicates that the thread is done before all
// system level cleanup has happened.
//
//-----------------------------------------------------------------------------------
#if defined(POSIX)
#define HAVE_IMP
@ -326,40 +213,25 @@ SimpleThread::isRunning() {
struct PosixThreadImplementation
{
pthread_t fThread;
UBool fRunning;
UBool fRan; // True if the thread was successfully started
};
extern "C" void* SimpleThreadProc(void *arg)
{
// This is the code that is run in the new separate thread.
SimpleThread *This = (SimpleThread *)arg;
This->run(); // Run the user code.
// The user function has returned. Set the flag indicating that this thread
// is done. Need a mutex for memory barrier purposes only, so that other thread
// will reliably see that the flag has changed.
PosixThreadImplementation *imp = (PosixThreadImplementation*)This->fImplementation;
umtx_lock(NULL);
imp->fRunning = FALSE;
umtx_unlock(NULL);
This->run();
return 0;
}
SimpleThread::SimpleThread()
{
PosixThreadImplementation *imp = new PosixThreadImplementation;
imp->fRunning = FALSE;
imp->fRan = FALSE;
fImplementation = imp;
}
SimpleThread::~SimpleThread()
{
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
if (imp->fRan) {
pthread_join(imp->fThread, NULL);
}
delete imp;
fImplementation = (void *)0xdeadbeef;
}
@ -371,16 +243,7 @@ int32_t SimpleThread::start()
static UBool attrIsInitialized = FALSE;
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
imp->fRunning = TRUE;
imp->fRan = TRUE;
#ifdef HPUX_CMA
if (attrIsInitialized == FALSE) {
rc = pthread_attr_create(&attr);
attrIsInitialized = TRUE;
}
rc = pthread_create(&(imp->fThread),attr,&SimpleThreadProc,(void*)this);
#else
if (attrIsInitialized == FALSE) {
rc = pthread_attr_init(&attr);
#if U_PLATFORM == U_PF_OS390
@ -398,53 +261,18 @@ int32_t SimpleThread::start()
#endif
attrIsInitialized = TRUE;
}
rc = pthread_create(&(imp->fThread),&attr,&SimpleThreadProc,(void*)this);
#endif
rc = pthread_create(&(imp->fThread), &attr, &SimpleThreadProc, (void*)this);
if (rc != 0) {
// some kind of error occured, the thread did not start.
imp->fRan = FALSE;
imp->fRunning = FALSE;
}
return rc;
}
UBool
SimpleThread::isRunning() {
// Note: Mutex functions are used here not for synchronization,
// but to force memory barriors to exist, to ensure that one thread
// can see changes made by another when running on processors
// with memory models having weak coherency.
void SimpleThread::join() {
PosixThreadImplementation *imp = (PosixThreadImplementation*)fImplementation;
umtx_lock(NULL);
UBool retVal = imp->fRunning;
umtx_unlock(NULL);
return retVal;
}
void SimpleThread::sleep(int32_t millis)
{
#if U_PLATFORM == U_PF_SOLARIS
sigignore(SIGALRM);
#endif
#ifdef HPUX_CMA
cma_sleep(millis/100);
#elif U_PLATFORM == U_PF_HPUX || U_PLATFORM == U_PF_OS390
millis *= 1000;
while(millis >= 1000000) {
usleep(999999);
millis -= 1000000;
}
if(millis > 0) {
usleep(millis);
}
#else
usleep(millis * 1000);
#endif
pthread_join(imp->fThread, NULL);
}
#endif
@ -453,30 +281,4 @@ void SimpleThread::sleep(int32_t millis)
#ifndef HAVE_IMP
#error No implementation for threads! Cannot test.
0 = 216; //die
#endif
//-------------------------------------------------------------------------------------------
//
// class ThreadWithStatus - a thread that we can check the status and error condition of
//
//-------------------------------------------------------------------------------------------
class ThreadWithStatus : public SimpleThread
{
public:
UBool getError() { return (fErrors > 0); }
UBool getError(UnicodeString& fillinError) { fillinError = fErrorString; return (fErrors > 0); }
virtual ~ThreadWithStatus(){}
protected:
ThreadWithStatus() : fErrors(0) {}
void error(const UnicodeString &error) {
fErrors++; fErrorString = error;
SimpleThread::errorFunc();
}
void error() { error("An error occured."); }
private:
int32_t fErrors;
UnicodeString fErrorString;
};
#endif // ICU_USE_THREADS

14
icu4c/source/test/intltest/simplethread.h
View file

@ -11,22 +11,16 @@
class U_EXPORT SimpleThread
{
public:
public:
SimpleThread();
virtual ~SimpleThread();
int32_t start(void); // start the thread
UBool isRunning(); // return true if a started thread has exited.
void join() {while (isRunning()) sleep(1);}; // Wait until thread finishes.
// TODO: add a real implementation. Ticket #11643
int32_t start(void); // start the thread. Return 0 if successfull.
void join(); // A thread must be joined before deleting its SimpleThread.
virtual void run(void) = 0; // Override this to provide the code to run
// in the thread.
private:
void *fImplementation;
public:
static void sleep(int32_t millis); // probably shouldn't go here but oh well.
static void errorFunc(); // Empty function, provides a single convenient place
// to break on errors.
};
#endif

886
icu4c/source/test/intltest/tsmthred.cpp
View file

File diff suppressed because it is too large Load diff

24
icu4c/source/test/intltest/tzfmttst.cpp
View file

@ -1,6 +1,6 @@
/*
*******************************************************************************
* Copyright (C) 2007-2014, International Business Machines Corporation and *
* Copyright (C) 2007-2015, International Business Machines Corporation and *
* others. All Rights Reserved. *
*******************************************************************************
*/
@ -678,11 +678,7 @@ TimeZoneFormatTest::TestTimeRoundTrip(void) {
data.END_TIME = END_TIME;
data.numDone = 0;
#if (ICU_USE_THREADS==0)
TestTimeRoundTripThread fakeThread(*this, data, 0);
fakeThread.run();
#else
TestTimeRoundTripThread **threads = new TestTimeRoundTripThread*[threadCount];
TestTimeRoundTripThread **threads = new TestTimeRoundTripThread*[nThreads];
int32_t i;
for (i = 0; i < nThreads; i++) {
threads[i] = new TestTimeRoundTripThread(*this, data, i);
@ -691,16 +687,11 @@ TimeZoneFormatTest::TestTimeRoundTrip(void) {
}
}
UBool done = false;
while (true) {
umtx_lock(NULL);
if (data.numDone == nLocales) {
done = true;
}
umtx_unlock(NULL);
if (done)
break;
SimpleThread::sleep(1000);
for (i = 0; i < nThreads; i++) {
threads[i]->join();
}
if (data.numDone != nLocales) {
errln("%s:%d data.numDone = %d, nLocales = %d", __FILE__, __LINE__, data.numDone, nLocales);
}
for (i = 0; i < nThreads; i++) {
@ -708,7 +699,6 @@ TimeZoneFormatTest::TestTimeRoundTrip(void) {
}
delete [] threads;
#endif
UDate total = 0;
logln("### Elapsed time by patterns ###");
for (int32_t i = 0; i < NUM_PATTERNS; i++) {