JThread.cpp

Go to the documentation of this file.

/***************************** License **********************************

 Copyright (C) 2008 by Communicative Machines
 http://www.cmlabs.com   All rights reserved.

 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 2.1 of the License, or (at your option) any later version.

 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.

 You should have received a copy of the GNU Lesser General Public
 License along with this library; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

************************************************************************/
// JThread.cpp: implementation of the JThread class.
//
//////////////////////////////////////////////////////////////////////

#include "JThread.h"

#ifdef WIN32
        #include "win32/JThread_Win32.cpp"
#else
        #include "linux/JThread_Linux.cpp"
#endif

#include "JSocket.h"
#include "Message.h"

namespace cmlabs {

#ifdef WIN32

        ObjectDictionary allThreadsStats;

        // *****************************************************************
        // allThreadsStats code
        // *****************************************************************

        bool JThread::addToAllThreadsStats(HANDLE aThread, ThreadStat* stat) {
                return allThreadsStats.put(JString(aThread), stat);
        }

        bool JThread::addToAllThreadsStats(HANDLE aThread) {
                return allThreadsStats.put(JString(aThread), NULL);
        }

        bool JThread::removeFromAllThreadsStats(HANDLE aThread) {
                bool res = allThreadsStats.remove(JString(aThread));
                return res;
        }

        ThreadStat JThread::getAllThreadsStats() {
                ThreadStat totalStat;
                HANDLE aThread;
                ThreadStat stat;
                for (int n=0; n<allThreadsStats.getCount(); n++) {
                        aThread = (HANDLE)(allThreadsStats.getKey(n).toPointer());
                        if (aThread != NULL) {
                                stat = getCPUUsage(aThread);
                                totalStat.userLast += stat.userLast;
                                totalStat.kernelLast += stat.kernelLast;
                        }
                }
                return totalStat;
        }
#else // WIN32
        ObjectDictionary* allThreadsStats = NULL;

        // *****************************************************************
        // allThreadsStats code
        // *****************************************************************

        bool JThread::addToAllThreadsStats(HANDLE aThread, ThreadStat* stat) {
                if (allThreadsStats == NULL)
                        allThreadsStats = new ObjectDictionary();
                return allThreadsStats->put(JString((long)aThread), stat);
        }

        bool JThread::addToAllThreadsStats(HANDLE aThread) {
                if (allThreadsStats == NULL)
                        allThreadsStats = new ObjectDictionary();
                return allThreadsStats->put(JString((long)aThread), NULL);
        }

        bool JThread::removeFromAllThreadsStats(HANDLE aThread) {
                if (allThreadsStats == NULL)
                        return true;
                bool res = allThreadsStats->remove(JString((long)aThread));
                if (allThreadsStats == NULL)
                        return true;
                if (allThreadsStats->getCount() == 0) {
                        delete(allThreadsStats);
                        allThreadsStats = NULL;
                }
                return res;
        }

        ThreadStat JThread::getAllThreadsStats() {

                ThreadStat totalStat;

                if (allThreadsStats == NULL)
                        return totalStat;

                HANDLE aThread;
                ThreadStat stat;
                for (int n=0; n<allThreadsStats->getCount(); n++) {
                        aThread = (HANDLE)(allThreadsStats->getKey(n).toLong());
                        if (aThread != NULL) {
                                stat = getCPUUsage(aThread);
                                totalStat.userLast += stat.userLast;
                                totalStat.kernelLast += stat.kernelLast;
                        }
                }
                return totalStat;
        }

#endif // WIN32






// *****************************************************************
// SysInfo Object
// *****************************************************************

SysInfo::SysInfo() {
        clear();
}

SysInfo::~SysInfo() {
}

bool SysInfo::clear() {
        osName = "";
        osVersionString = "";
        cpuArchitecture = "";
        hostname = "";
        osType = "";

        osTotalMemory = 0;
        cpuSpeed = 0;
        cpuCount = 0;
//      procMemoryUsage = 0;
        procAverageCPUUsageKernel = 0;
        procAverageCPUUsageUser = 0;
        procAverageCPUUsage = 0;
        procCurrentCPUUsageKernel = 0;
        procCurrentCPUUsageUser = 0;
        procCurrentCPUUsage = 0;
        return true;
}

bool SysInfo::update() {
        
//      StopWatch st;
//      st.start();
        
        JThread* thread = new JThread();
//      st.setMark("Thread Created");

        ThreadStat av = thread->procAverageCPUUsage();
        ThreadStat cu = thread->procCurrentCPUUsage();
//      st.setMark("Thread Got Average and Current");

        osName = thread->osGetName();
//      st.setMark("Got OS Name");
        osType = thread->osGetType();
//      st.setMark("Got OS Type");
        osVersionString = thread->osGetVersion();
//      st.setMark("Got OS Version");

        osTotalMemory = thread->osGetTotalMemory();
//      st.setMark("Got OS Mem");
        cpuSpeed = thread->osGetCPUSpeed();
//      st.setMark("Got CPU Speed");
        cpuCount = thread->osGetCPUCount();
//      st.setMark("Got CPU Count");
        cpuArchitecture = thread->osGetMachineArch();
//      st.setMark("Got CPU Arch");
        hostname = thread->osGetMachineName();
//      st.setMark("Got Hostname");

//      procMemoryUsage = (double) thread->procMemUsage()/(1024*1024);
//      st.setMark("Got MemUse");
        procAverageCPUUsageKernel = av.percentKernelCPU;
        procAverageCPUUsageUser = av.percentUserCPU;
        procAverageCPUUsage = av.percentCPU;
        procCurrentCPUUsageKernel = cu.percentKernelCPU;
        procCurrentCPUUsageUser = cu.percentUserCPU;
        procCurrentCPUUsage = cu.percentCPU;
//      st.setMark("Calced CPU");
//      st.stop();
//      printf("%s\n", (char*) st.printDetails());

        delete(thread);
        return true;
}

int SysInfo::getOSVersionMajor() {
        Collection col = osVersionString.split(".");
        if (col.getCount() > 0)
                return col.get(0).toInt();
        else
                return 0;
}

int SysInfo::getOSVersionMinor() {
        Collection col = osVersionString.split(".");
        if (col.getCount() > 1)
                return col.get(1).toInt();
        else
                return 0;
}

int SysInfo::getOSVersionSub() {
        Collection col = osVersionString.split(".");
        if (col.getCount() > 2)
                return col.get(2).toInt();
        else
                return 0;
}

int SysInfo::getOSVersionBuild() {
        Collection col = osVersionString.split(".");
        if (col.getCount() > 3)
                return col.get(3).toInt();
        else
                return 0;
}

JString SysInfo::getOSVersionText() {
        Collection col = osVersionString.splitOnWhiteSpaces();
        if (col.getCount() > 1)
                return col.getLast();
        else
                return "";
}

Object* SysInfo::clone() const {
        SysInfo* sysInfo = new SysInfo();
        *sysInfo = *this;
        return sysInfo;
}

bool SysInfo::equals(const Object* o2) const {
        if ((o2 == NULL) || (!isSameClass(o2)))
                return 0;
//      if ( (o2 == NULL) || (!o2->getClass().equalsIgnoreCase("SysInfo")) )
//              return false;
        
        SysInfo* si = (SysInfo*) o2;

        if ( (osName.length() != 0) && (si->osName.length() != 0) && (!osName.matches(si->osName)) )
                return false;
        if ( (osType.length() != 0) && (si->osType.length() != 0) && (!osType.matches(si->osType)) )
                return false;
        if ( (osVersionString.length() != 0) && (si->osVersionString.length() != 0) && (!osVersionString.matches(si->osVersionString)) )
                return false;
        if ( (cpuArchitecture.length() != 0) && (si->cpuArchitecture.length() != 0) && (!cpuArchitecture.matches(si->cpuArchitecture)) )
                return false;
        if ( (hostname.length() != 0) && (si->hostname.length() != 0) && (!hostname.matches(si->hostname)) )
                return false;
        if ( (osTotalMemory != 0) && (si->osTotalMemory != 0) && (osTotalMemory <= si->osTotalMemory) )
                return false;
        if ( (cpuSpeed != 0) && (si->cpuSpeed != 0) && (cpuSpeed <= si->cpuSpeed) )
                return false;
        if ( (cpuCount != 0) && (si->cpuCount != 0) && (cpuCount <= si->cpuCount) )
                return false;
//      if ( (procMemoryUsage != 0) && (si->procMemoryUsage != 0) && (procMemoryUsage != si->procMemoryUsage) )
//              return false;
/*      if ( (procAverageCPUUsageKernel != 0) && (si->procAverageCPUUsageKernel != 0) && (procAverageCPUUsageKernel != si->procAverageCPUUsageKernel) )
                return false;
        if ( (procAverageCPUUsageUser != 0) && (si->procAverageCPUUsageUser != 0) && (procAverageCPUUsageUser != si->procAverageCPUUsageUser) )
                return false;
        if ( (procAverageCPUUsage != 0) && (si->procAverageCPUUsage != 0) && (procAverageCPUUsage != si->procAverageCPUUsage) )
                return false;
        if ( (procCurrentCPUUsageKernel != 0) && (si->procCurrentCPUUsageKernel != 0) && (procCurrentCPUUsageKernel != si->procCurrentCPUUsageKernel) )
                return false;
        if ( (procCurrentCPUUsageUser != 0) && (si->procCurrentCPUUsageUser != 0) && (procCurrentCPUUsageUser != si->procCurrentCPUUsageUser) )
                return false;
        if ( (procCurrentCPUUsage != 0) && (si->procCurrentCPUUsage != 0) && (procCurrentCPUUsage != si->procCurrentCPUUsage) )
                return false;*/

        return true;
}

JString SysInfo::print() {
        return JString::format("\
System Info\n osname=\"%s\"\n ostype=\"%s\"\n osversionstring=\"%s\"\n arch=\"%s\"\n\
 hostname=\"%s\"\n osmem=\"%f\"\n cpuspeed=\"%f\"\n\
 cpucount=\"%d\"\n procavgkernel=\"%f\"\n procavguser=\"%f\"\n\
 procavg=\"%f\"\n proccurkernel=\"%f\"\n proccuruser=\"%f\"\n proccur=\"%f\"\n",
        (char*) osName,
        (char*) osType,
        (char*) osVersionString,
        (char*) cpuArchitecture,
        (char*) hostname,
        osTotalMemory,
        cpuSpeed,
        cpuCount,
//      procMemoryUsage,
        procAverageCPUUsageKernel,
        procAverageCPUUsageUser,
        procAverageCPUUsage,
        procCurrentCPUUsageKernel,
        procCurrentCPUUsageUser,
        procCurrentCPUUsage);
}

JString SysInfo::toHTML() {
        return JString::format("\
<table><tr><td colspan=\"2\">System Info</td></tr><tr><td>osname</td><td>%s</td></tr><tr><td>ostype</td><td>%s</td></tr><tr><td>osversionstring</td><td>%s</td></tr><tr><td>arch</td><td>%s</td></tr><tr><td>\
hostname</td><td>%s</td></tr><tr><td>osmem</td><td>%f</td></tr><tr><td>cpuspeed</td><td>%f</td></tr><tr><td>\
cpucount</td><td>%d</td></tr><tr><td>procavgkernel</td><td>%f</td></tr><tr><td>procavguser</td><td>%f</td></tr><tr><td>\
procavg</td><td>%f</td></tr><tr><td>proccurkernel</td><td>%f</td></tr><tr><td>proccuruser</td><td>%f</td></tr><tr><td>proccur</td><td>%f</td></tr></table>",
        (char*) osName,
        (char*) osType,
        (char*) osVersionString,
        (char*) cpuArchitecture,
        (char*) hostname,
        osTotalMemory,
        cpuSpeed,
        cpuCount,
//      procMemoryUsage,
        procAverageCPUUsageKernel,
        procAverageCPUUsageUser,
        procAverageCPUUsage,
        procCurrentCPUUsageKernel,
        procCurrentCPUUsageUser,
        procCurrentCPUUsage);
}

JString SysInfo::toXML(JString tag, JString content) {

        JString ending;
        if (content.length() == 0)
                ending = JString::format(" />");
        else
                ending = JString::format(">%s</%s>", (char*) content.xmlStringEncode(), (char*) tag);

        return JString::format("\
<%s osname=\"%s\" ostype=\"%s\" osversionstring=\"%s\" arch=\"%s\"\
 hostname=\"%s\" osmem=\"%f\" cpuspeed=\"%f\"\
 cpucount=\"%d\" procavgkernel=\"%f\" procavguser=\"%f\"\
 procavg=\"%f\" proccurkernel=\"%f\" proccuruser=\"%f\" proccur=\"%f\"%s",
        (char*) tag,
        (char*) osName,
        (char*) osType,
        (char*) osVersionString,
        (char*) cpuArchitecture,
        (char*) hostname,
        osTotalMemory,
        cpuSpeed,
        cpuCount,
//      procMemoryUsage,
        procAverageCPUUsageKernel,
        procAverageCPUUsageUser,
        procAverageCPUUsage,
        procCurrentCPUUsageKernel,
        procCurrentCPUUsageUser,
        procCurrentCPUUsage,
        (char*) ending);
}

JString SysInfo::toXML() {

        return toXML("sysinfo", "");
}

bool SysInfo::fromXML(XMLNode* node) {

        if (node == NULL)
                return false;

        osName = node->getAttribute("osname");
        osType = node->getAttribute("ostype");
        osVersionString = node->getAttribute("osversionstring");
        cpuArchitecture = node->getAttribute("arch");
        hostname = node->getAttribute("hostname");
        if (node->hasAttribute("osmem"))
                osTotalMemory = node->getAttribute("osmem").toDouble();
        if (node->hasAttribute("cpuspeed"))
                cpuSpeed = node->getAttribute("cpuspeed").toDouble();
        if (node->hasAttribute("cpucount"))
                cpuCount = node->getAttribute("cpucount").toInt();

        if (node->hasAttribute("procavgkernel"))
                procAverageCPUUsageKernel = node->getAttribute("procavgkernel").toDouble();
        if (node->hasAttribute("procavguser"))
                procAverageCPUUsageUser = node->getAttribute("procavguser").toDouble();
        if (node->hasAttribute("procavg"))
                procAverageCPUUsage = node->getAttribute("procavg").toDouble();
        if (node->hasAttribute("proccurkernel"))
                procCurrentCPUUsageKernel = node->getAttribute("proccurkernel").toDouble();
        if (node->hasAttribute("proccuruser"))
                procCurrentCPUUsageUser = node->getAttribute("proccuruser").toDouble();
        if (node->hasAttribute("proccur"))
                procCurrentCPUUsage = node->getAttribute("proccur").toDouble();

        return true;
}




// *****************************************************************
// ThreadStat Object
// *****************************************************************

ThreadStat::ThreadStat() {
        timeLast.tv_sec = timeLast.tv_usec = 0;
        userLast = kernelLast = realTimeElapse = cpuUserUsage = cpuKernelUsage = cpuUsage = (longlong) 0;
        percentKernelCPU = percentUserCPU = percentCPU = 0;
}

Object* ThreadStat::clone() const {
        ThreadStat* stat = new ThreadStat();
        *stat = *this;
        return stat;
}

bool ThreadStat::isEmpty() {
        return ( (timeLast.tv_sec == 0) && (timeLast.tv_usec == 0) && (userLast == 0) && (kernelLast == 0) );
}

JString ThreadStat::print() {

//      char str[100000];

/*      sprintf(str, "userLast: %.f\nkernelLast: %.f\nrealTimeElapse: %.f (%.2f sec)\ncpuUserUsage: %.f\ncpuKernelUsage: %.f\ncpuUsage: %.f\ncpuUserUsage: %.2f %% \ncpuKernelUsage: %.2f %% \ncpuUsage: %.2f %% \n",
                (double)userLast, (double)kernelLast, (double)realTimeElapse,
                ((double)realTimeElapse/(longlong)1000000),
                (double)cpuUserUsage, (double)cpuKernelUsage, (double)cpuUsage,
                percentUserCPU, percentKernelCPU, percentCPU);

        return JString(str);
*/
        JString str = JString::format("userLast: %.f\nkernelLast: %.f\nrealTimeElapse: %.f (%.2f sec)\ncpuUserUsage: %.f\ncpuKernelUsage: %.f\ncpuUsage: %.f\ncpuUserUsage: %.2f %% \ncpuKernelUsage: %.2f %% \ncpuUsage: %.2f %% \n",
                (double)userLast, (double)kernelLast, (double)realTimeElapse,
                ((double)realTimeElapse/(longlong)1000000),
                (double)cpuUserUsage, (double)cpuKernelUsage, (double)cpuUsage,
                percentUserCPU, percentKernelCPU, percentCPU);
        return str;
}

// *****************************************************************
// PerfStat Object
// *****************************************************************

PerfStat::PerfStat() {
        runCount = 0;
        msgMax = 0;
        msgStored = 0;
        msgReceived = 0;
        msgPosted = 0;
        msgSent = 0;
        msgWoken = 0;
        msgProcessed = 0;
        bytesReceived = 0;
        bytesSent = 0;
        currentCPUUsage = 0;
        totalRunSeconds = 0;
        totalCPUSeconds = 0;
        deltaSeconds = 0;
        deltaRunSeconds = 0;
        deltaCPUSeconds = 0;
        currentSystemUsage = 0;
        averageSystemUsage = 0;
        totalSystemUsage = 0;
        streamsCount = 0;
        streamsTotalSize = 0;
        streamTotalInRate = 0;
        streamTotalOutRate = 0;
        streamsTotalSizeEver = 0;
        lastMessageTrigger = NULL;
        lastMessagePosted = NULL;
//      lastMessageTrigger = new Message("From", "To", "Type");
//      lastMessagePosted = new Message("From", "To", "Type");
}

PerfStat::PerfStat(JString xml) {
        runCount = 0;
        msgMax = 0;
        msgStored = 0;
        msgReceived = 0;
        msgPosted = 0;
        msgSent = 0;
        msgWoken = 0;
        msgProcessed = 0;
        bytesReceived = 0;
        bytesSent = 0;
        currentCPUUsage = 0;
        totalRunSeconds = 0;
        totalCPUSeconds = 0;
        deltaSeconds = 0;
        deltaRunSeconds = 0;
        deltaCPUSeconds = 0;
        currentSystemUsage = 0;
        averageSystemUsage = 0;
        totalSystemUsage = 0;
        streamsCount = 0;
        streamsTotalSize = 0;
        streamTotalInRate = 0;
        streamTotalOutRate = 0;
        streamsTotalSizeEver = 0;
        lastMessageTrigger = NULL;
        lastMessagePosted = NULL;
        Object::fromXML(xml);
}

PerfStat::PerfStat(XMLNode* node) {
        runCount = 0;
        msgMax = 0;
        msgStored = 0;
        msgReceived = 0;
        msgPosted = 0;
        msgSent = 0;
        msgWoken = 0;
        msgProcessed = 0;
        bytesReceived = 0;
        bytesSent = 0;
        currentCPUUsage = 0;
        totalRunSeconds = 0;
        totalCPUSeconds = 0;
        deltaSeconds = 0;
        deltaRunSeconds = 0;
        deltaCPUSeconds = 0;
        currentSystemUsage = 0;
        averageSystemUsage = 0;
        totalSystemUsage = 0;
        streamsCount = 0;
        streamsTotalSize = 0;
        streamTotalInRate = 0;
        streamTotalOutRate = 0;
        streamsTotalSizeEver = 0;
        lastMessagePosted = NULL;
        lastMessageTrigger = NULL;
        fromXML(node);
}

PerfStat::PerfStat(const PerfStat &p) {
        runCount = p.runCount;
        msgMax = p.msgMax;
        msgStored = p.msgStored;
        msgReceived = p.msgReceived;
        msgPosted = p.msgPosted;
        msgSent = p.msgSent;
        msgWoken = p.msgWoken;
        msgProcessed = p.msgProcessed;
        bytesReceived = p.bytesReceived;
        bytesSent = p.bytesSent;
        currentCPUUsage = p.currentCPUUsage;
        totalRunSeconds = p.totalRunSeconds;
        totalCPUSeconds = p.totalCPUSeconds;
        deltaSeconds = p.deltaSeconds;
        deltaRunSeconds = p.deltaRunSeconds;
        deltaCPUSeconds = p.deltaCPUSeconds;
        currentSystemUsage = p.currentSystemUsage;
        averageSystemUsage = p.averageSystemUsage;
        totalSystemUsage = p.totalSystemUsage;
        streamsCount = p.streamsCount;
        streamsTotalSize = p.streamsTotalSize;
        streamTotalInRate = p.streamTotalInRate;
        streamTotalOutRate = p.streamTotalOutRate;
        streamsTotalSizeEver = p.streamsTotalSizeEver;
        lastMessageTrigger = NULL;
        lastMessagePosted = NULL;
        if (p.mutex.EnterMutex(500)) {
                this->setLastMessageTrigger(p.lastMessageTrigger);
                this->setLastMessagePost(p.lastMessagePosted);
                p.mutex.LeaveMutex();
        }
}

PerfStat& PerfStat::operator=(const PerfStat &p) {
        name = p.name;
        runCount = p.runCount;
        msgMax = p.msgMax;
        msgStored = p.msgStored;
        msgReceived = p.msgReceived;
        msgPosted = p.msgPosted;
        msgSent = p.msgSent;
        msgWoken = p.msgWoken;
        msgProcessed = p.msgProcessed;
        bytesReceived = p.bytesReceived;
        bytesSent = p.bytesSent;
        currentCPUUsage = p.currentCPUUsage;
        totalRunSeconds = p.totalRunSeconds;
        totalCPUSeconds = p.totalCPUSeconds;
        deltaSeconds = p.deltaSeconds;
        deltaRunSeconds = p.deltaRunSeconds;
        deltaCPUSeconds = p.deltaCPUSeconds;
        currentSystemUsage = p.currentSystemUsage;
        averageSystemUsage = p.averageSystemUsage;
        totalSystemUsage = p.totalSystemUsage;
        streamsCount = p.streamsCount;
        streamsTotalSize = p.streamsTotalSize;
        streamTotalInRate = p.streamTotalInRate;
        streamTotalOutRate = p.streamTotalOutRate;
        streamsTotalSizeEver = p.streamsTotalSizeEver;
        if (p.mutex.EnterMutex(500)) {
                this->setLastMessageTrigger(p.lastMessageTrigger);
                this->setLastMessagePost(p.lastMessagePosted);
                p.mutex.LeaveMutex();
        }
        else {
                if (mutex.EnterMutex(500)) {
                        if (lastMessageTrigger != NULL)
                                delete(lastMessageTrigger);
                        if (lastMessagePosted != NULL)
                                delete(lastMessagePosted);
                        mutex.LeaveMutex();
                }
                lastMessageTrigger = NULL;
                lastMessagePosted = NULL;
        }
        return *this;
}

PerfStat::~PerfStat() {
        if (mutex.EnterMutex(500)) {
                if (lastMessageTrigger != NULL)
                        delete(lastMessageTrigger);
                lastMessageTrigger = NULL;
                if (lastMessagePosted != NULL)
                        delete(lastMessagePosted);
                lastMessagePosted = NULL;
                mutex.LeaveMutex();
        }
        else {
                printf("******* PerfStat ignoring Mutex *******");
                // Do it anyway...
                if (lastMessageTrigger != NULL)
                        delete(lastMessageTrigger);
                lastMessageTrigger = NULL;
                if (lastMessagePosted != NULL)
                        delete(lastMessagePosted);
                lastMessagePosted = NULL;
        }
}


Object* PerfStat::clone() const {
        PerfStat* stat = new PerfStat();
        *stat = *this;
        return stat;
}

bool PerfStat::setLastMessageTrigger(const Message* msg) {
        if (mutex.EnterMutex(500)) {
                delete(lastMessageTrigger);
                lastMessageTrigger = NULL;
                if (msg != NULL) {
                        lastMessageTrigger = msg->shallowClone();
                //      lastMessageTrigger = msg->tinyClone();
                //      lastMessageTrigger = new Message();
                }
                mutex.LeaveMutex();
                return true;
        }
        else
                return false;
}

bool PerfStat::setLastMessagePost(const Message* msg) {
        if (mutex.EnterMutex(500)) {
                delete(lastMessagePosted);
                lastMessagePosted = NULL;
                if (msg != NULL) {
                        lastMessagePosted = msg->shallowClone();
                //      lastMessagePosted = msg->tinyClone();
                //      lastMessagePosted = new Message();
                }
                mutex.LeaveMutex();
                return true;
        }
        else
                return false;
}

bool PerfStat::fromXML(XMLNode* node) {
        if (node == NULL)
                return false;

        if (!node->getTag().equalsIgnoreCase("perfstat"))
                return false;

        ObjectCollection* col = node->getChildTags();
        if ( (col == NULL) || (col->getCount() < 2))
                return false;

        name = node->getAttribute("name");
        runCount = node->getAttribute("count").toInt();
        msgReceived = node->getAttribute("received").toInt();
        msgWoken = node->getAttribute("woken").toInt();
        msgPosted = node->getAttribute("posted").toInt();
        msgSent = node->getAttribute("sent").toInt();
        msgProcessed = node->getAttribute("processed").toInt();
        msgMax = node->getAttribute("max").toLong();
        msgStored = node->getAttribute("stored").toLong();
        bytesReceived = node->getAttribute("bytesreceived").toLong();
        bytesSent = node->getAttribute("bytessent").toLong();
        currentCPUUsage = node->getAttribute("currentcpu").toDouble();
        totalRunSeconds = node->getAttribute("totalrun").toDouble();
        totalCPUSeconds = node->getAttribute("totalcpu").toDouble();
        deltaSeconds = node->getAttribute("delta").toDouble();
        deltaRunSeconds = node->getAttribute("deltarun").toDouble();
        deltaCPUSeconds = node->getAttribute("deltacpu").toDouble();
        currentSystemUsage = node->getAttribute("currentsystem").toDouble();
        averageSystemUsage = node->getAttribute("averagesystem").toDouble();
        totalSystemUsage = node->getAttribute("totalsystem").toDouble();
        streamsCount = node->getAttribute("streamscount").toLong();
        streamsTotalSize = node->getAttribute("streamssize").toLong();
        streamTotalInRate = node->getAttribute("streamsratein").toDouble();
        streamTotalOutRate = node->getAttribute("streamsrateout").toDouble();
        streamsTotalSizeEver = node->getAttribute("streamsever").toDouble();

        created = JTime((XMLNode*)col->get(0));
        lastUpdated = JTime((XMLNode*)col->get(1));

        if (col->getCount() > 2) {
                if (mutex.EnterMutex(500)) {
                        delete(lastMessageTrigger);
                        // lastMessageTrigger = Object::createObjectFromXML((XMLNode*)col.get(0));
                        lastMessageTrigger = new Message((XMLNode*)col->get(2));
                        mutex.LeaveMutex();
                }
        }
        if (col->getCount() > 3) {
                if (mutex.EnterMutex(500)) {
                        delete(lastMessagePosted);
                        // lastMessagePosted = Object::createObjectFromXML((XMLNode*)col.get(0));
                        lastMessagePosted = new Message((XMLNode*)col->get(3));
                        mutex.LeaveMutex();
                }
        }

        return true;
}

JString PerfStat::toXML() {
        JString xml;
        if (lastMessageTrigger != NULL) {
                if (mutex.EnterMutex(500)) {
                        xml = lastMessageTrigger->toXML().indentXML();
                        mutex.LeaveMutex();
                }
        }
        if (lastMessagePosted != NULL) {
                if (xml.length() == 0) {
                        Message* msg = new Message();
                        xml = msg->toXML().indentXML();
                        delete(msg);
                }
                if (mutex.EnterMutex(500)) {
                        xml += lastMessagePosted->toXML().indentXML();
                        mutex.LeaveMutex();
                }
        }
        return JString::format("<perfstat name=\"%s\" count=\"%d\" received=\"%d\" woken=\"%d\" posted=\"%d\" sent=\"%d\" processed=\"%d\" \
max=\"%d\" stored=\"%d\" bytesreceived=\"%d\" bytessent=\"%d\" streamscount=\"%d\" streamssize=\"%d\" streamsratein=\"%.10f\" streamsrateout=\"%.10f\" streamsever=\"%.10f\" \
currentcpu=\"%.10f\" totalrun=\"%.10f\" totalcpu=\"%.10f\" delta=\"%.10f\" deltarun=\"%.10f\" deltacpu=\"%.10f\" \
currentsystem=\"%.10f\" averagesystem=\"%.10f\" totalsystem=\"%.10f\">\n%s%s%s</perfstat>",
                (char*) name.xmlStringEncode(), runCount, msgReceived, msgWoken, msgPosted, msgSent, msgProcessed,
                msgMax, msgStored, bytesReceived, bytesSent,
                streamsCount, streamsTotalSize, streamTotalInRate, streamTotalOutRate, streamsTotalSizeEver,
                currentCPUUsage, totalRunSeconds, totalCPUSeconds, deltaSeconds, deltaRunSeconds, deltaCPUSeconds,
                currentSystemUsage, averageSystemUsage, totalSystemUsage, (char*) created.toXML().indentXML(), (char*) lastUpdated.toXML().indentXML(), (char*) xml);
}

char* PerfStat::toBinary(int* len) {
        JString xml = toXML();
        int l;
        char* buffer = xml.getCharCopy(l);
        *len = l+1;
        return buffer;
}

bool PerfStat::fromBinary(char* data, int len) {
        JString xml = data;
        return Object::fromXML(xml);
}


JString PerfStat::print() {
        JString msgs;
        if (mutex.EnterMutex(500)) {
                if (lastMessageTrigger != NULL)
                        msgs = JString::format("Last Trigger: %s\n", (char*) lastMessageTrigger->printShort());
                if (lastMessagePosted != NULL)
                        msgs += JString::format("Last Posted: %s\n", (char*) lastMessagePosted->printShort());
                mutex.LeaveMutex();
        }
        JTime now;
        return JString::format("perfstat[%s] count: %d woken: %d posted: %d sent: %d bytesrec: %d bytessent: %d proc: %d currentcpu: %.2f current: %.4f average: %.4f total: %.4f\n%s",
                (char*) name, runCount, msgWoken, msgPosted, msgSent, bytesReceived, bytesSent, msgProcessed, currentCPUUsage, currentSystemUsage, averageSystemUsage, totalSystemUsage, (char*) msgs);
}

bool PerfStat::isOlderThan(long ms) {
        JTime now;
        return (now - lastUpdated > ms);
}







// *****************************************************************
// Thread stat on local thread
// *****************************************************************

ThreadStat JThread::getLocalThreadStatistics() {
        return getCPUUsageOnThread(hThread);
}

bool JThread::resetLocalThreadStatistics() {
        return resetCPUUsageOnThread(hThread);
}

JString JThread::printLocalThreadStatistics() {
        return printThreadStatistics(getLocalThreadStatistics());
}


// *****************************************************************
// Thread stat on calling thread
// *****************************************************************

ThreadStat JThread::getCallingThreadStatistics() {
        #ifdef WIN32
                return getCPUUsageOnThread(getCallingThreadID());
        #else // WIN32
                pthread_t* p = getCallingThreadID();
                ThreadStat stat = getCPUUsageOnThread(p);
                delete(p);
                return stat;
        #endif // WIN32
}

bool JThread::resetCallingThreadStatistics() {
        #ifdef WIN32
                return resetCPUUsageOnThread(getCallingThreadID());
        #else // WIN32
                pthread_t* p = getCallingThreadID();
                bool res = resetCPUUsageOnThread(p);
                delete(p);
                return res;
        #endif // WIN32
}

JString JThread::printCallingThreadStatistics() {
        return printThreadStatistics(getCallingThreadStatistics());
}


// *****************************************************************
// Thread stat on thread id
// *****************************************************************

ThreadStat JThread::getCurrentCPUUsage() {
        
        // We have the last stat in procLastStat, now get the new stat
        ThreadStat newStat = getCPUUsage(NULL);
        
        newStat.realTimeElapse = (newStat.timeLast.tv_sec - procLastStat.timeLast.tv_sec) * 1000000
                                                + (newStat.timeLast.tv_usec - procLastStat.timeLast.tv_usec);
        newStat.cpuUserUsage = newStat.userLast - procLastStat.userLast;
        newStat.cpuKernelUsage = newStat.kernelLast - procLastStat.kernelLast;
        newStat.cpuUsage = newStat.cpuUserUsage + newStat.cpuKernelUsage;

        if (newStat.cpuUsage > newStat.realTimeElapse) {
                double factor = (double) newStat.realTimeElapse / (double) newStat.cpuUsage;
                newStat.cpuUserUsage = (longlong)(factor * newStat.cpuUserUsage);
                newStat.cpuKernelUsage = (longlong)(factor * newStat.cpuKernelUsage);
                newStat.cpuUsage = (longlong)(factor * newStat.cpuUsage);
        }

        newStat.percentUserCPU = (newStat.cpuUserUsage / (double) newStat.realTimeElapse) * 100.0;
        newStat.percentKernelCPU = (newStat.cpuKernelUsage / (double) newStat.realTimeElapse) * 100.0;
        newStat.percentCPU = (newStat.cpuUsage / (double) newStat.realTimeElapse) * 100.0;

//      printf("Current Usage: %s\n", (char*) newStat.print());

        procLastStat = getCPUUsage(NULL);

        return newStat;
}

ThreadStat JThread::getAverageCPUUsage() {

        // We have the start stat in procStartStat, now get the new stat
        ThreadStat newStat = getCPUUsage(NULL);
        
        newStat.realTimeElapse = (newStat.timeLast.tv_sec - procStartStat.timeLast.tv_sec) * 1000000
                                                + (newStat.timeLast.tv_usec - procStartStat.timeLast.tv_usec);
        newStat.cpuUserUsage = newStat.userLast - procStartStat.userLast;
        newStat.cpuKernelUsage = newStat.kernelLast - procStartStat.kernelLast;
        newStat.cpuUsage = newStat.cpuUserUsage + newStat.cpuKernelUsage;

        if (newStat.cpuUsage > newStat.realTimeElapse) {
                double factor = (double) newStat.realTimeElapse / (double) newStat.cpuUsage;
                newStat.cpuUserUsage = (longlong)(factor * newStat.cpuUserUsage);
                newStat.cpuKernelUsage = (longlong)(factor * newStat.cpuKernelUsage);
                newStat.cpuUsage = (longlong)(factor * newStat.cpuUsage);
        }

        newStat.percentUserCPU = (newStat.cpuUserUsage / (double) newStat.realTimeElapse) * 100.0;
        newStat.percentKernelCPU = (newStat.cpuKernelUsage / (double) newStat.realTimeElapse) * 100.0;
        newStat.percentCPU = (newStat.cpuUsage / (double) newStat.realTimeElapse) * 100.0;

//      printf("Average Usage: %s\n", (char*) newStat.print());

        return newStat;
}

ThreadStat JThread::getCPUUsageOnThread(HANDLE aThread) {

        ThreadStat newStat;

        if (aThread == NULL)
                return newStat;

        ThreadStat oldStat = getStoredCPUUsageOnThread(aThread);
        if (oldStat.isEmpty())
                return ThreadStat();
        newStat = getCPUUsage(aThread);
        if (newStat.isEmpty())
                return ThreadStat();

        newStat.realTimeElapse = (newStat.timeLast.tv_sec - oldStat.timeLast.tv_sec) * 1000000
                                                + (newStat.timeLast.tv_usec - oldStat.timeLast.tv_usec);
        newStat.cpuUserUsage = newStat.userLast - oldStat.userLast;
        newStat.cpuKernelUsage = newStat.kernelLast - oldStat.kernelLast;
        newStat.cpuUsage = newStat.cpuUserUsage + newStat.cpuKernelUsage;

        double factor;
        if ((newStat.cpuUsage > newStat.realTimeElapse) && (newStat.cpuUsage > 0)) {
                factor = (double) newStat.realTimeElapse / (double) newStat.cpuUsage;
                newStat.cpuUserUsage = (longlong)(factor * newStat.cpuUserUsage);
                newStat.cpuKernelUsage = (longlong)(factor * newStat.cpuKernelUsage);
                newStat.cpuUsage = (longlong)(factor * newStat.cpuUsage);
        }

        newStat.percentUserCPU = (newStat.cpuUserUsage / (double) newStat.realTimeElapse) * 100.0;
        newStat.percentKernelCPU = (newStat.cpuKernelUsage / (double) newStat.realTimeElapse) * 100.0;
        newStat.percentCPU = (newStat.cpuUsage / (double) newStat.realTimeElapse) * 100.0;

        return newStat;

}

bool JThread::resetCPUUsageOnThread(HANDLE aThread) {

        if (aThread == NULL)
                return false;

        if (!resetMutex.EnterMutex(1000)) {
                printf("resetCPUUsageOnThread - Couldn't get Mutex\n");
                return false;
        }

//      int id = (int) aThread;
        statDict.put(JString(aThread), getCPUUsage(aThread).clone());
//      printf("[%d] Resetting StoredCPUUsage for %d\n", (int) this, id);

        resetMutex.LeaveMutex();

//      printf("Now just a dummy resetCPUUsage...\n");
        return true;
}

ThreadStat JThread::getStoredCPUUsageOnThread(HANDLE aThread) {

        ThreadStat ts;
        if (aThread == NULL)
                return ts;

        if (!resetMutex.EnterMutex(1000)) {
                printf("getStoredCPUUsageOnThread - Couldn't get Mutex\n");
                return ts;
        }

//      int id = (int) aThread;
        ThreadStat* pts = (ThreadStat*) statDict.get(JString(aThread));
        if (pts == NULL) {
        //      resetCPUUsageOnThread(aThread);
        //      printf("[%d] Didn't find any StoredCPUUsage, creating new one for %d\n", (int) this, id);
                statDict.put(JString(aThread), getCPUUsage(aThread).clone());
                pts = (ThreadStat*) statDict.get(JString(aThread));
                if (pts == NULL) {
                        if (DEBUGLEVEL(KITCHENSINK)) {
                                printf("*** Error getStoredCPUUsageOnThread ***\n");
                        }
                }
                else
                        ts = *pts;
        }
        else
                ts = *pts;

        resetMutex.LeaveMutex();

        return ts;
}

JString JThread::osGetMachineName() {
        if (localhostName.length() > 0)
                return localhostName;

#ifdef WIN32

        char* hname = new char[1000];
        if (gethostname(hname, 1000) == 0) {
                localhostName = hname;
                delete [] hname;
                return localhostName;
        }
        else {
                int er = WSAGetLastError();
                if (er == WSANOTINITIALISED) {
                        WSADATA info;
                        if (WSAStartup(MAKEWORD(1,1), &info) == 0) {
                                // Now we can retry the socket() function
                                if (gethostname(hname, 1000) == 0) {
                                        localhostName = hname;
                                        delete [] hname;
                                        return localhostName;
                                }
                        }
                }
        }

        JSocket* socket = new JSocket("", 80);
        localhostName = socket->getLocalHostname();
        delete(socket);

#elif defined(Darwin)
        localhostName = runOSTextCommand("uname -n");
#else
        localhostName = runOSTextCommand("uname -n");
#endif // WIN32

        return localhostName;
}

JString JThread::osGetMachineAddress() {
        JSocket* socket = new JSocket("", 80);
        JString address = socket->getLocalIPAddress();
        delete(socket);
        return address;
}

JString JThread::osGetType() {
        #ifdef WIN32
                #ifdef _WIN32_WCE
                        return "PocketPC";
                #else
                        #ifdef CYGWIN
                                return "CygWin";
                        #else
                                return "Win32";
                        #endif
                #endif
        #else
                #if defined(Darwin)
                        return "OSX";
                #else
                        return "Linux";
                #endif // Darwin
        #endif
}


// *****************************************************************
// Printing
// *****************************************************************

JString JThread::printThreadStatistics(ThreadStat newStat) {
        char str[400];
        
//      sprintf(str, "User: %ld | Kernel: %ld | CPU: %ld | JTime: %ld | User: %3.1f%% | Kernel: %3.1f%% | CPU: %3.1f%%\n",
//              stat.cpuUserUsage, stat.cpuKernelUsage, stat.cpuUsage, stat.realTimeElapse,
//              stat.percentUserCPU * 100, stat.percentKernelCPU * 100, stat.percentCPU * 100);

        if (newStat.realTimeElapse > 0) {
                newStat.percentKernelCPU = ( (double) newStat.cpuKernelUsage /  (double) newStat.realTimeElapse);
                newStat.percentUserCPU = ( (double) newStat.cpuUserUsage /  (double) newStat.realTimeElapse);
                newStat.percentCPU = ( (double) newStat.cpuUsage /  (double) newStat.realTimeElapse);

                sprintf(str, "Time elapse: %ld usec | User: %3.1f%% | Kernel: %3.1f%% | CPU: %3.1f%%",
                        newStat.realTimeElapse, (double)newStat.percentUserCPU * 100.0, (double)newStat.percentKernelCPU * 100.0, (double)newStat.percentCPU * 100.0);
        }
        else {
                sprintf(str, "Time elapsed: 0 usec");
        }

        return JString(str);
}

JTime JThread::getStartTime() {
        return threadStartTime;
}
JTime JThread::getEndTime() {
        return threadEndTime;
}

bool JThread::terminateWait(int timeout) {
        if (!terminate())
                return false;

        JTime t;
        while (t.getAge() < timeout) {
                if (!isRunning())
                        break;
                waitThread(10);
        }
        return isRunning();
}


// *****************************************************************
// Unit Testing
// *****************************************************************

bool JThread::unitTest() {

        JTime t;
        JMutex mutex1;
        JMutex mutex2;
        JMutex mutex3;

        t = JTime();
        if (!mutex1.EnterMutex(500)) {
                unitTestString += "No access by Mutex 1!\n";
                return false;
        }
        if (t.getAge() > 50) {
                unitTestString += JString::format("Mutex 1 waited too long: %.3f ms >> 0 ms!\n", t.getMicroAge()/1000.0);
                return false;
        }

        t = JTime();
        if (!mutex2.EnterMutex(500)) {
                unitTestString += "No access by Mutex 2!\n";
                return false;
        }
        if (t.getAge() > 50) {
                unitTestString += JString::format("Mutex 2 waited too long: %.3f ms >> 0 ms!\n", t.getMicroAge()/1000.0);
                return false;
        }

        t = JTime();
        if (!mutex3.EnterMutex(500)) {
                unitTestString += "No access by Mutex 3!\n";
                return false;
        }
        if (t.getAge() > 50) {
                unitTestString += JString::format("Mutex 3 waited too long: %.3f ms >> 0 ms!\n", t.getMicroAge()/1000.0);
                return false;
        }

        unitTestString = "";
        JSemaphore* sem = new JSemaphore();
        JSemaphore* sem2 = new JSemaphore();

        t = JTime();
        if (sem->wait(500)) {
                unitTestString += "First semaphore should not have triggered!\n";
                return false;
        }
        if (t.getAge() < 490) {
                unitTestString += JString::format("First semaphore triggered too fast: %.3f ms < 500 ms!\n", t.getMicroAge()/1000.0);
                return false;
        }

        sem->post();

        t = JTime();
        if (!sem->wait(500)) {
                unitTestString += "First semaphore should have triggered!\n";
                return false;
        }
        if (t.getAge() > 50) {
                unitTestString += JString::format("First semaphore triggered too slow: %.3f ms << 500 ms!\n", t.getMicroAge()/1000.0);
                return false;
        }

        t = JTime();
        if (sem->wait(500)) {
                unitTestString += "First semaphore should not have triggered again!\n";
                return false;
        }
        if (t.getAge() < 490) {
                unitTestString += JString::format("First semaphore triggered again too fast: %.3f ms < 500 ms!\n", t.getMicroAge()/1000.0);
                return false;
        }

        JThread* thr = new JThread(false);
        thr->publicSemaphore = sem;
        thr->testSemaphore = sem2;
        thr->testMutex = &mutex1;

        // Start Thread
        thr->start();
        thr->waitThread(100);

        sem->post();
        sem2->post();

        unitTestString += "Waiting for first semaphore...\n";
        thr->waitThread(100);
        if (!sem->wait(5000)) {
                unitTestString += "Waiting for first semaphore failed!\n";
                return false;
        }

        if (!sem2->wait(5000)) {
                unitTestString += "Waiting for test semaphore failed!\n";
                return false;
        }

        sem->post();
        
        unitTestString += "Waiting for second semaphore...\n";
        thr->waitThread(100);
        if (!sem->wait(5000)) {
                unitTestString += "Waiting for second semaphore failed!\n";
                return false;
        }

        sem->post();
        
        unitTestString += "Waiting for third semaphore...\n";
        thr->waitThread(100);
        if (!sem->wait(5000)) {
                unitTestString += "Waiting for third semaphore failed!\n";
                return false;
        }

        sem->post();
        
        unitTestString += "Waiting for forth semaphore...\n";
        thr->waitThread(100);
        if (!sem->wait(5000)) {
                unitTestString += "Waiting for forth semaphore failed!\n";
                // On really fast and really slow computers, this one sometimes fails
                //  so we just accept this as the rest worked just fine...
                // return false;
        }
        
        
        thr->waitThread(100);

        unitTestString += "Exiting...\n";

        mutex1.LeaveMutex();
        mutex2.LeaveMutex();
        mutex3.LeaveMutex();

        delete(sem);
        delete(sem2);
        delete(thr);

        return true;
}





void JThread::run()
{
        JTime t = JTime();
        if (this->testMutex->EnterMutex(500)) {
                printf("Access to Mutex 1 when no access should be given!\n");
                return;
        }
        if (t.getAge() < 490) {
                printf("Mutex 1 waited too short: %.3f ms < 500 ms!\n", t.getMicroAge()/1000.0);
                return;
        }



        if (publicSemaphore == NULL) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("JThread: PublicSemaphore NULL!!!\n");
                }
                return;
        }

        if (!publicSemaphore->wait(5000)) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("JThread: RUN 1 WAIT FAILED!!!\n");
                }
                return;
        }

        if (!testSemaphore->wait(5000)) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("JThread: RUN 1 1/2 WAIT FAILED!!!\n");
                }
                return;
        }
        testSemaphore->post();

        // Now we have sem first time - post
        publicSemaphore->post();

        this->waitThread(100);
        if (!publicSemaphore->wait(5000)) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("JThread: RUN 2 WAIT FAILED!!!\n");
                }
                return;
        }

        // Now we have sem second time - post
        publicSemaphore->post();

        this->waitThread(100);
        if (!publicSemaphore->wait(5000)) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("JThread: RUN 3 WAIT FAILED!!!\n");
                }
                return;
        }

        // Now we have sem third time - post
        publicSemaphore->post();

        this->waitThread(100);
        if (!publicSemaphore->wait(5000)) {
                if (DEBUGLEVEL(KITCHENSINK)) {
                        printf("JThread: RUN 4 WAIT FAILED!!!\n");
                }
                return;
        }

        this->waitThread(100);
        publicSemaphore->post();

}








ThreadStat JThread::procAverageCPUUsage() {
        ThreadStat stat = getAverageCPUUsage();
        return stat;
}

ThreadStat JThread::procCurrentCPUUsage() {
        ThreadStat stat = getCurrentCPUUsage();
        return stat;
}










bool JThread::priorityTest() {

        printf("Creating threads with priorities 5, 10, 15, ..., 95, 100\n");

        // Create ThreadTesters
        JThreadTester* test100 = new JThreadTester(100);
        JThreadTester* test95 = new JThreadTester(95);
        JThreadTester* test90 = new JThreadTester(90);
        JThreadTester* test85 = new JThreadTester(85);
        JThreadTester* test80 = new JThreadTester(80);
        JThreadTester* test75 = new JThreadTester(75);
        JThreadTester* test70 = new JThreadTester(70);
        JThreadTester* test65 = new JThreadTester(65);
        JThreadTester* test60 = new JThreadTester(60);
        JThreadTester* test55 = new JThreadTester(55);
        JThreadTester* test50 = new JThreadTester(50);
        JThreadTester* test45 = new JThreadTester(45);
        JThreadTester* test40 = new JThreadTester(40);
        JThreadTester* test35 = new JThreadTester(35);
        JThreadTester* test30 = new JThreadTester(30);
        JThreadTester* test25 = new JThreadTester(25);
        JThreadTester* test20 = new JThreadTester(20);
        JThreadTester* test15 = new JThreadTester(15);
        JThreadTester* test10 = new JThreadTester(10);
        JThreadTester* test05 = new JThreadTester(05);

        printf("Starting all threads...\n");

        bool t100 = true;
        bool t95 = true;
        bool t90 = true;
        bool t85 = true;
        bool t80 = true;
        bool t75 = true;
        bool t70 = true;
        bool t65 = true;
        bool t60 = true;
        bool t55 = true;
        bool t50 = true;
        bool t45 = true;
        bool t40 = true;
        bool t35 = true;
        bool t30 = true;
        bool t25 = true;
        bool t20 = true;
        bool t15 = true;
        bool t10 = true;
        bool t05 = true;

        test100->start();
        test95->start();
        test90->start();
        test85->start();
        test80->start();
        test75->start();
        test70->start();
        test65->start();
        test60->start();
        test55->start();
        test50->start();
        test45->start();
        test40->start();
        test35->start();
        test30->start();
        test25->start();
        test20->start();
        test15->start();
        test10->start();
        test05->start();

        if (!test100->setPriority(test100->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test100->ver);
        }
        if (!test95->setPriority(test95->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test95->ver);
        }
        if (!test90->setPriority(test90->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test90->ver);
        }
        if (!test85->setPriority(test85->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test85->ver);
        }
        if (!test80->setPriority(test80->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test80->ver);
        }
        if (!test75->setPriority(test75->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test75->ver);
        }
        if (!test70->setPriority(test70->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test70->ver);
        }
        if (!test65->setPriority(test65->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test65->ver);
        }
        if (!test60->setPriority(test60->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test60->ver);
        }
        if (!test55->setPriority(test55->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test55->ver);
        }
        if (!test50->setPriority(test50->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test50->ver);
        }
        if (!test45->setPriority(test45->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test45->ver);
        }
        if (!test40->setPriority(test40->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test40->ver);
        }
        if (!test35->setPriority(test35->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test35->ver);
        }
        if (!test30->setPriority(test30->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test30->ver);
        }
        if (!test25->setPriority(test25->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test25->ver);
        }
        if (!test20->setPriority(test20->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test20->ver);
        }
        if (!test15->setPriority(test15->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test15->ver);
        }
        if (!test10->setPriority(test10->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test10->ver);
        }
        if (!test05->setPriority(test05->ver)) {
                printf("Could not SetPriority(%d), not super user...\n", test05->ver);
        }

        printf("Please wait while testing priorities...\n\n");
        ObjectDictionary times;
        while(t100 || t95 || t90 || t85 || t80 || t75 || t70 || t65 || t60 || t55 || t50 || t45 || t40 || t35 || t30 || t25 || t20 || t15 || t10 || t05) {

                if (t100 && (!test100->isRunning())) {
                        times.put("100", test100->getEndTime().clone());
                        t100 = false;
                }
                if (t95 && (!test95->isRunning())) {
                        times.put("95", test95->getEndTime().clone());
                        t95 = false;
                }
                if (t90 && (!test90->isRunning())) {
                        times.put("90", test90->getEndTime().clone());
                        t90 = false;
                }
                if (t85 && (!test85->isRunning())) {
                        times.put("85", test85->getEndTime().clone());
                        t85 = false;
                }
                if (t80 && (!test80->isRunning())) {
                        times.put("80", test80->getEndTime().clone());
                        t80 = false;
                }
                if (t75 && (!test75->isRunning())) {
                        times.put("75", test75->getEndTime().clone());
                        t75 = false;
                }
                if (t70 && (!test70->isRunning())) {
                        times.put("70", test70->getEndTime().clone());
                        t70 = false;
                }
                if (t65 && (!test65->isRunning())) {
                        times.put("65", test65->getEndTime().clone());
                        t65 = false;
                }
                if (t60 && (!test60->isRunning())) {
                        times.put("60", test60->getEndTime().clone());
                        t60 = false;
                }
                if (t55 && (!test55->isRunning())) {
                        times.put("55", test55->getEndTime().clone());
                        t55 = false;
                }
                if (t50 && (!test50->isRunning())) {
                        times.put("50", test50->getEndTime().clone());
                        t50 = false;
                }
                if (t45 && (!test45->isRunning())) {
                        times.put("45", test45->getEndTime().clone());
                        t45 = false;
                }
                if (t40 && (!test40->isRunning())) {
                        times.put("40", test40->getEndTime().clone());
                        t40 = false;
                }
                if (t35 && (!test35->isRunning())) {
                        times.put("35", test35->getEndTime().clone());
                        t35 = false;
                }
                if (t30 && (!test30->isRunning())) {
                        times.put("30", test30->getEndTime().clone());
                        t30 = false;
                }
                if (t25 && (!test25->isRunning())) {
                        times.put("25", test25->getEndTime().clone());
                        t25 = false;
                }
                if (t20 && (!test20->isRunning())) {
                        times.put("20", test20->getEndTime().clone());
                        t20 = false;
                }
                if (t15 && (!test15->isRunning())) {
                        times.put("15", test15->getEndTime().clone());
                        t15 = false;
                }
                if (t10 && (!test10->isRunning())) {
                        times.put("10", test10->getEndTime().clone());
                        t10 = false;
                }
                if (t05 && (!test05->isRunning())) {
                        times.put("05", test05->getEndTime().clone());
                        t05 = false;
                }
                this->waitThread(100);
        }

        if (times.getCount() < 10) {
                printf("Test failed - no results\n");
                return false;
        }

        double dist = ((JTime*)times.getLast())->microDifference(*(JTime*)times.getFirst()) / 10.0;
        if (dist <= 1) {
                printf("Test failed - results too fast...\n");
                return false;
        }

        double t;
//      printf("Priorities found to be equal:\nEqual: 100 ");
        JTime* t1, *t2;
        for (int n=1; n<times.getCount(); n++) {
                t2 = (JTime*)times.get(n);
                if (n > 0) {
                        t1 = (JTime*)times.get(n-1);
                        t = t2->microDifference(*t1);
                        printf("%3s %s (%.3f) \n", (char*)times.getKey(n), (char*)t2->printTimeMS(), t/1000.0);
                }
                else
                        printf("%3s %s\n", (char*)times.getKey(n), (char*)t2->printTimeMS());
                //      printf("%3s %s\n", (char*)times.getKey(n), (char*)t2->printTimeMS(), t/1000.0);
//              printf("%s (%.3f) ", (char*)times.getKey(n), t);
//              if (t > dist)
//                      printf("\nEqual: ");
        }
        printf("\n\nTypical test time: %.3f ms\n\n", dist/1000.0);

        delete(test100);
        delete(test95);
        delete(test90);
        delete(test85);
        delete(test80);
        delete(test75);
        delete(test70);
        delete(test65);
        delete(test60);
        delete(test55);
        delete(test50);
        delete(test45);
        delete(test40);
        delete(test35);
        delete(test30);
        delete(test25);
        delete(test20);
        delete(test15);
        delete(test10);
        delete(test05);

        printf("Test success\n");
        return true;
}



JThreadTester::JThreadTester(int pri) : JThread(false) {
        ver = pri;
}

JThreadTester::~JThreadTester() {
}

void JThreadTester::run() {

        int louter = 10;
        int linner = 100000;
        double test;

        this->waitThread(1000);

        for (int n=0; n<louter; n++) {
                for (int m=0; m<linner; m++) {
                        test = pow((double)sqrt((double)10000) - 1, 2.55);
                }
        //      printf("Priority: %3d -> Milestone: %3d\n", ver, n);
                fflush(stdout);
                this->waitThread(0);
        }
        JTime now;
        printf("Priority: %3d   %s\n", ver, (char*)now.printTimeMS());

}













} // namespace cmlabs

---