//
//********************************************************************
// Copyright (C) 2002-2005, International Business Machines
// Corporation and others. All Rights Reserved.
//********************************************************************
//
// File threadtest.cpp
//
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include "unicode/utypes.h"
#include "unicode/uclean.h"
#include "umutex.h"
#include "threadtest.h"
//------------------------------------------------------------------------------
//
// Factory functions for creating different test types.
//
//------------------------------------------------------------------------------
extern AbstractThreadTest *createStringTest();
extern AbstractThreadTest *createConvertTest();
//------------------------------------------------------------------------------
//
// Windows specific code for starting threads
//
//------------------------------------------------------------------------------
#ifdef U_WINDOWS
#include "Windows.h"
#include "process.h"
typedef void (*ThreadFunc)(void *);
class ThreadFuncs // This class isolates OS dependent threading
{ // functions from the rest of ThreadTest program.
public:
static void Sleep(int millis) {::Sleep(millis);};
static void startThread(ThreadFunc, void *param);
static unsigned long getCurrentMillis();
static void yield() {::Sleep(0);};
};
void ThreadFuncs::startThread(ThreadFunc func, void *param)
{
unsigned long x;
x = _beginthread(func, 0x10000, param);
if (x == -1)
{
fprintf(stderr, "Error starting thread. Errno = %d\n", errno);
exit(-1);
}
}
unsigned long ThreadFuncs::getCurrentMillis()
{
return (unsigned long)::GetTickCount();
}
// #elif defined (POSIX)
#else
//------------------------------------------------------------------------------
//
// UNIX specific code for starting threads
//
//------------------------------------------------------------------------------
#include <pthread.h>
#include <unistd.h>
#include <errno.h>
#include <sched.h>
#include <sys/timeb.h>
extern "C" {
typedef void (*ThreadFunc)(void *);
typedef void *(*pthreadfunc)(void *);
class ThreadFuncs // This class isolates OS dependent threading
{ // functions from the rest of ThreadTest program.
public:
static void Sleep(int millis);
static void startThread(ThreadFunc, void *param);
static unsigned long getCurrentMillis();
static void yield() {sched_yield();};
};
void ThreadFuncs::Sleep(int millis)
{
int seconds = millis/1000;
if (seconds <= 0) seconds = 1;
::sleep(seconds);
}
void ThreadFuncs::startThread(ThreadFunc func, void *param)
{
unsigned long x;
pthread_t tId;
//thread_t tId;
#if defined(_HP_UX) && defined(XML_USE_DCE)
x = pthread_create( &tId, pthread_attr_default, (pthreadfunc)func, param);
#else
pthread_attr_t attr;
pthread_attr_init(&attr);
x = pthread_create( &tId, &attr, (pthreadfunc)func, param);
#endif
if (x == -1)
{
fprintf(stderr, "Error starting thread. Errno = %d\n", errno);
exit(-1);
}
}
unsigned long ThreadFuncs::getCurrentMillis() {
timeb aTime;
ftime(&aTime);
return (unsigned long)(aTime.time*1000 + aTime.millitm);
}
}
// #else
// #error This platform is not supported
#endif
//------------------------------------------------------------------------------
//
// struct runInfo Holds the info extracted from the command line and data
// that is shared by all threads.
// There is only one of these, and it is static.
// During the test, the threads will access this info without
// any synchronization.
//
//------------------------------------------------------------------------------
const int MAXINFILES = 25;
struct RunInfo
{
bool quiet;
bool verbose;
int numThreads;
int totalTime;
int checkTime;
AbstractThreadTest *fTest;
bool stopFlag;
bool exitFlag;
int32_t runningThreads;
};
//------------------------------------------------------------------------------
//
// struct threadInfo Holds information specific to an individual thread.
// One of these is set up for each thread in the test.
// The main program monitors the threads by looking
// at the status stored in these structs.
//
//------------------------------------------------------------------------------
struct ThreadInfo
{
bool fHeartBeat; // Set true by the thread each time it finishes
// a test.
unsigned int fCycles; // Number of cycles completed.
int fThreadNum; // Identifying number for this thread.
ThreadInfo() {
fHeartBeat = false;
fCycles = 0;
fThreadNum = -1;
}
};
//
//------------------------------------------------------------------------------
//
// Global Data
//
//------------------------------------------------------------------------------
RunInfo gRunInfo;
ThreadInfo *gThreadInfo;
UMTX gStopMutex; // Lets main thread suspend test threads.
UMTX gInfoMutex; // Synchronize access to data passed between
// worker threads and the main thread
//----------------------------------------------------------------------
//
// parseCommandLine Read through the command line, and save all
// of the options in the gRunInfo struct.
//
// Display the usage message if the command line
// is no good.
//
// Probably ought to be a member function of RunInfo.
//
//----------------------------------------------------------------------
void parseCommandLine(int argc, char **argv)
{
gRunInfo.quiet = false; // Set up defaults for run.
gRunInfo.verbose = false;
gRunInfo.numThreads = 2;
gRunInfo.totalTime = 0;
gRunInfo.checkTime = 10;
try // Use exceptions for command line syntax errors.
{
int argnum = 1;
while (argnum < argc)
{
if (strcmp(argv[argnum], "-quiet") == 0)
gRunInfo.quiet = true;
else if (strcmp(argv[argnum], "-verbose") == 0)
gRunInfo.verbose = true;
else if (strcmp(argv[argnum], "--help") == 0 ||
(strcmp(argv[argnum], "?") == 0)) {throw 1; }
else if (strcmp(argv[argnum], "-threads") == 0)
{
++argnum;
if (argnum >= argc)
throw 1;
gRunInfo.numThreads = atoi(argv[argnum]);
if (gRunInfo.numThreads < 0)
throw 1;
}
else if (strcmp(argv[argnum], "-time") == 0)
{
++argnum;
if (argnum >= argc)
throw 1;
gRunInfo.totalTime = atoi(argv[argnum]);
if (gRunInfo.totalTime < 1)
throw 1;
}
else if (strcmp(argv[argnum], "-ctime") == 0)
{
++argnum;
if (argnum >= argc)
throw 1;
gRunInfo.checkTime = atoi(argv[argnum]);
if (gRunInfo.checkTime < 1)
throw 1;
}
else if (strcmp(argv[argnum], "string") == 0)
{
gRunInfo.fTest = createStringTest();
}
else if (strcmp(argv[argnum], "convert") == 0)
{
gRunInfo.fTest = createConvertTest();
}
else
{
fprintf(stderr, "Unrecognized command line option. Scanning \"%s\"\n",
argv[argnum]);
throw 1;
}
argnum++;
}
// We've reached the end of the command line parameters.
// Fail if no test name was specified.
if (gRunInfo.fTest == NULL) {
fprintf(stderr, "No test specified.\n");
throw 1;
}
}
catch (int)
{
fprintf(stderr, "usage: threadtest [-threads nnn] [-time nnn] [-quiet] [-verbose] test-name\n"
" -quiet Suppress periodic status display. \n"
" -verbose Display extra messages. \n"
" -threads nnn Number of threads. Default is 2. \n"
" -time nnn Total time to run, in seconds. Default is forever.\n"
" -ctime nnn Time between extra consistency checks, in seconds. Default 10\n"
" testname string | convert\n"
);
exit(1);
}
}
//----------------------------------------------------------------------
//
// threadMain The main function for each of the swarm of test threads.
// Run in a loop, executing the runOnce() test function each time.
//
//
//----------------------------------------------------------------------
extern "C" {
void threadMain (void *param)
{
ThreadInfo *thInfo = (ThreadInfo *)param;
if (gRunInfo.verbose)
printf("Thread #%d: starting\n", thInfo->fThreadNum);
umtx_atomic_inc(&gRunInfo.runningThreads);
//
//
while (true)
{
if (gRunInfo.verbose )
printf("Thread #%d: starting loop\n", thInfo->fThreadNum);
//
// If the main thread is asking us to wait, do so by locking gStopMutex
// which will block us, since the main thread will be holding it already.
//
umtx_lock(&gInfoMutex);
UBool stop = gRunInfo.stopFlag; // Need mutex for processors with flakey memory models.
umtx_unlock(&gInfoMutex);
if (stop) {
if (gRunInfo.verbose) {
fprintf(stderr, "Thread #%d: suspending\n", thInfo->fThreadNum);
}
umtx_atomic_dec(&gRunInfo.runningThreads);
while (gRunInfo.stopFlag) {
umtx_lock(&gStopMutex);
umtx_unlock(&gStopMutex);
}
umtx_atomic_inc(&gRunInfo.runningThreads);
if (gRunInfo.verbose) {
fprintf(stderr, "Thread #%d: restarting\n", thInfo->fThreadNum);
}
}
//
// The real work of the test happens here.
//
gRunInfo.fTest->runOnce();
umtx_lock(&gInfoMutex);
thInfo->fHeartBeat = true;
thInfo->fCycles++;
UBool exitNow = gRunInfo.exitFlag;
umtx_unlock(&gInfoMutex);
//
// If main thread says it's time to exit, break out of the loop.
//
if (exitNow) {
break;
}
}
umtx_atomic_dec(&gRunInfo.runningThreads);
// Returning will kill the thread.
return;
}
}
//----------------------------------------------------------------------
//
// main
//
//----------------------------------------------------------------------
int main (int argc, char **argv)
{
//
// Parse the command line options, and create the specified kind of test.
//
parseCommandLine(argc, argv);
//
// Fire off the requested number of parallel threads
//
if (gRunInfo.numThreads == 0)
exit(0);
gRunInfo.exitFlag = FALSE;
gRunInfo.stopFlag = TRUE; // Will cause the new threads to block
umtx_lock(&gStopMutex);
gThreadInfo = new ThreadInfo[gRunInfo.numThreads];
int threadNum;
for (threadNum=0; threadNum < gRunInfo.numThreads; threadNum++)
{
gThreadInfo[threadNum].fThreadNum = threadNum;
ThreadFuncs::startThread(threadMain, &gThreadInfo[threadNum]);
}
unsigned long startTime = ThreadFuncs::getCurrentMillis();
int elapsedSeconds = 0;
int timeSinceCheck = 0;
//
// Unblock the threads.
//
gRunInfo.stopFlag = FALSE; // Unblocks the worker threads.
umtx_unlock(&gStopMutex);
//
// Loop, watching the heartbeat of the worker threads.
// Each second,
// display "+" if all threads have completed at least one loop
// display "." if some thread hasn't since previous "+"
// Each "ctime" seconds,
// Stop all the worker threads at the top of their loop, then
// call the test's check function.
//
while (gRunInfo.totalTime == 0 || gRunInfo.totalTime > elapsedSeconds)
{
ThreadFuncs::Sleep(1000); // We sleep while threads do their work ...
if (gRunInfo.quiet == false && gRunInfo.verbose == false)
{
char c = '+';
int threadNum;
umtx_lock(&gInfoMutex);
for (threadNum=0; threadNum < gRunInfo.numThreads; threadNum++)
{
if (gThreadInfo[threadNum].fHeartBeat == false)
{
c = '.';
break;
};
}
umtx_unlock(&gInfoMutex);
fputc(c, stdout);
fflush(stdout);
if (c == '+')
for (threadNum=0; threadNum < gRunInfo.numThreads; threadNum++)
gThreadInfo[threadNum].fHeartBeat = false;
}
//
// Update running times.
//
timeSinceCheck -= elapsedSeconds;
elapsedSeconds = (ThreadFuncs::getCurrentMillis() - startTime) / 1000;
timeSinceCheck += elapsedSeconds;
//
// Call back to the test to let it check its internal validity
//
if (timeSinceCheck >= gRunInfo.checkTime) {
if (gRunInfo.verbose) {
fprintf(stderr, "Main: suspending all threads\n");
}
umtx_lock(&gStopMutex); // Block the worker threads at the top of their loop
gRunInfo.stopFlag = TRUE;
for (;;) {
umtx_lock(&gInfoMutex);
UBool done = gRunInfo.runningThreads == 0;
umtx_unlock(&gInfoMutex);
if (done) { break;}
ThreadFuncs::yield();
}
gRunInfo.fTest->check();
if (gRunInfo.quiet == false && gRunInfo.verbose == false) {
fputc('C', stdout);
}
if (gRunInfo.verbose) {
fprintf(stderr, "Main: starting all threads.\n");
}
gRunInfo.stopFlag = FALSE; // Unblock the worker threads.
umtx_unlock(&gStopMutex);
timeSinceCheck = 0;
}
};
//
// Time's up, we are done. (We only get here if this was a timed run)
// Tell the threads to exit.
//
gRunInfo.exitFlag = true;
for (;;) {
umtx_lock(&gInfoMutex);
UBool done = gRunInfo.runningThreads == 0;
umtx_unlock(&gInfoMutex);
if (done) { break;}
ThreadFuncs::yield();
}
//
// Tally up the total number of cycles completed by each of the threads.
//
double totalCyclesCompleted = 0;
for (threadNum=0; threadNum < gRunInfo.numThreads; threadNum++) {
totalCyclesCompleted += gThreadInfo[threadNum].fCycles;
}
double cyclesPerMinute = totalCyclesCompleted / (double(gRunInfo.totalTime) / double(60));
printf("\n%8.1f cycles per minute.", cyclesPerMinute);
//
// Memory should be clean coming out
//
delete gRunInfo.fTest;
delete [] gThreadInfo;
umtx_destroy(&gInfoMutex);
umtx_destroy(&gStopMutex);
u_cleanup();
return 0;
}