continuation of last commit

pvDataApp/misc/thread.cpp

@@ -0,0 +1,210 @@
+/* thread.cpp */
+/**
+ * Copyright - See the COPYRIGHT that is included with this distribution.
+ * EPICS pvDataCPP is distributed subject to a Software License Agreement found
+ * in file LICENSE that is included with this distribution.
+ */
+#include <cstddef>
+#include <cstdlib>
+#include <cstddef>
+#include <string>
+#include <cstdio>
+#include <stdexcept>
+
+#include <epicsThread.h>
+#include <epicsEvent.h>
+#include "lock.h"
+#include "event.h"
+#include "thread.h"
+#include "linkedList.h"
+
+namespace epics { namespace pvData { 
+
+static unsigned int epicsPriority[] = {
+        epicsThreadPriorityLow,
+        epicsThreadPriorityLow + 15,
+        epicsThreadPriorityMedium - 15,
+        epicsThreadPriorityMedium,
+        epicsThreadPriorityMedium + 15,
+        epicsThreadPriorityHigh - 15,
+        epicsThreadPriorityHigh
+};
+
+unsigned int const * const ThreadPriorityFunc::getEpicsPriorities()
+{
+    return epicsPriority;
+}
+
+
+static String threadPriorityNames[] = {
+    String("lowest"),String("lower"),String("low"),
+    String("middle"),
+    String("high"),String("higher"),String("highest")
+};
+
+class ThreadListElement;
+typedef LinkedListNode<ThreadListElement> ThreadListNode;
+typedef LinkedList<ThreadListElement> ThreadList;
+
+static volatile int64 totalConstruct = 0;
+static volatile int64 totalDestruct = 0;
+static Mutex *globalMutex = 0;
+static ThreadList *threadList;
+
+static int64 getTotalConstruct()
+{
+    Lock xx(globalMutex);
+    return totalConstruct;
+}
+
+static int64 getTotalDestruct()
+{
+    Lock xx(globalMutex);
+    return totalDestruct;
+}
+
+static ConstructDestructCallback *pConstructDestructCallback;
+
+static void init()
+{
+     static Mutex mutex = Mutex();
+     Lock xx(&mutex);
+     if(globalMutex==0) {
+        globalMutex = new Mutex();
+        threadList = new ThreadList();
+        pConstructDestructCallback = new ConstructDestructCallback(
+            String("thread"),
+            getTotalConstruct,getTotalDestruct,0);
+     }
+}
+
+
+class ThreadListElement {
+public:
+    ThreadListElement(Thread *thread) : thread(thread),node(new ThreadListNode(this)){}
+    ~ThreadListElement(){delete node;}
+    Thread *thread;
+    ThreadListNode *node;
+};
+
+
+int ThreadPriorityFunc::getEpicsPriority(ThreadPriority threadPriority) {
+        return epicsPriority[threadPriority];
+}
+
+extern  "C" void myFunc ( void * pPvt );
+
+
+class ThreadPvt {
+public:
+    ThreadPvt(Thread *thread,String name,
+        ThreadPriority priority, Runnable*runnable);
+    virtual ~ThreadPvt();
+    void ready();
+public: // only used within this source module
+    Thread *thread;
+    String name;
+    ThreadPriority priority;
+    Runnable *runnable;
+    bool isReady;
+    ThreadListElement *threadListElement;
+    Event *waitDone;
+    epicsThreadId id;
+};
+
+extern "C" void myFunc ( void * pPvt )
+{
+    ThreadPvt *threadPvt = (ThreadPvt *)pPvt;
+    threadPvt->runnable->run();
+    threadPvt->waitDone->signal();
+}
+
+ThreadPvt::ThreadPvt(Thread *thread,String name,
+    ThreadPriority priority, Runnable *runnable)
+: thread(thread),name(name),priority(priority),
+  runnable(runnable),
+  isReady(false),
+  threadListElement(new ThreadListElement(thread)),
+  waitDone(new Event()),
+  id(epicsThreadCreate(
+        name.c_str(),
+        epicsPriority[priority],
+        epicsThreadGetStackSize(epicsThreadStackSmall),
+        myFunc,this))
+{
+    init();
+    Lock xx(globalMutex);
+    threadList->addTail(threadListElement->node);
+    totalConstruct++;
+}
+
+ThreadPvt::~ThreadPvt()
+{
+    bool result = waitDone->wait(2.0);
+    if(!result) {
+        throw std::logic_error(String("delete thread but run did not return"));
+        String message("destroy thread ");
+        message += thread->getName();
+        message += " but run did not return";
+        throw std::logic_error(message);
+    }
+    if(!threadListElement->node->isOnList()) {
+        String message("destroy thread ");
+        message += thread->getName();
+        message += " is not on threadlist";
+        throw std::logic_error(message);
+    }
+    threadList->remove(threadListElement->node);
+    delete waitDone;
+    delete threadListElement;
+    Lock xx(globalMutex);
+    totalDestruct++;
+}
+
+Thread::Thread(String name,ThreadPriority priority,Runnable *runnable)
+: pImpl(new ThreadPvt(this,name,priority,runnable))
+{
+}
+
+Thread::~Thread()
+{
+   delete pImpl;
+}
+
+ConstructDestructCallback *Thread::getConstructDestructCallback()
+{
+    init();
+    return pConstructDestructCallback;
+}
+
+void Thread::sleep(double seconds)
+{
+    epicsThreadSleep(seconds);;
+}
+
+String Thread::getName()
+{
+    return pImpl->name;
+}
+
+ThreadPriority Thread::getPriority()
+{
+    return pImpl->priority;
+}
+
+void Thread::showThreads(StringBuilder buf)
+{
+    init();
+    Lock xx(globalMutex);
+    ThreadListNode *node = threadList->getHead();    
+    while(node!=0) {
+        Thread *thread = node->getObject()->thread;
+        *buf += thread->getName();
+        *buf += " ";
+        *buf += threadPriorityNames[thread->getPriority()];
+        *buf += "\n";
+        node = threadList->getNext(node);
+    }
+}
+
+}}