move all examples to separate top level build areas.

Documentation needs updating.

arrayPerformance/src/arrayPerformance.cpp

@@ -0,0 +1,198 @@
+/* arrayPerformance.cpp */
+/**
+ * Copyright - See the COPYRIGHT that is included with this distribution.
+ * EPICS pvData is distributed subject to a Software License Agreement found
+ * in file LICENSE that is included with this distribution.
+ */
+/**
+ * @author mrk
+ * @date 2013.08.08
+ */
+
+#include <pv/lock.h>
+#include <pv/arrayPerformance.h>
+
+namespace epics { namespace pvDatabase { 
+
+using namespace epics::pvData;
+using std::tr1::static_pointer_cast;
+using std::tr1::dynamic_pointer_cast;
+using std::cout;
+using std::endl;
+using std::ostringstream;
+
+ArrayPerformancePtr ArrayPerformance::create(
+    epics::pvData::String const & recordName,
+        size_t size,
+        double delay)
+{
+    epics::pvData::PVStructurePtr pvStructure =
+       epics::pvData::getStandardPVField()->scalarArray(epics::pvData::pvLong,"timeStamp,alarm");
+    ArrayPerformancePtr pvRecord(
+        new ArrayPerformance(recordName,pvStructure,size,delay));
+    if(!pvRecord->init()) pvRecord.reset();
+    return pvRecord;
+}
+
+ArrayPerformance::ArrayPerformance(
+    epics::pvData::String const & recordName,
+    epics::pvData::PVStructurePtr const & pvStructure,
+        size_t size,
+        double delay)
+: PVRecord(recordName,pvStructure),
+  size(size),
+  delay(delay),
+  isDestroyed(false)
+{
+    pvTimeStamp.attach(pvStructure->getSubField("timeStamp"));
+}
+
+ArrayPerformance::~ArrayPerformance()
+{
+}
+
+bool ArrayPerformance::init()
+{
+    
+    initPVRecord();
+    PVScalarArrayPtr pvScalarArray = getPVStructure()->getScalarArrayField("value",pvLong);
+    if(pvScalarArray==NULL) return false;
+    pvValue = static_pointer_cast<PVLongArray>(pvScalarArray);
+    ArrayPerformancePtr xxx = dynamic_pointer_cast<ArrayPerformance>(getPtrSelf());
+    arrayPerformanceThread = ArrayPerformanceThreadPtr(new ArrayPerformanceThread(xxx));
+    arrayPerformanceThread->init();
+    return true;
+}
+
+void ArrayPerformance::start()
+{
+    arrayPerformanceThread->start();
+}
+
+void ArrayPerformance::process()
+{
+    timeStamp.getCurrent();
+    pvTimeStamp.set(timeStamp);
+}
+
+void ArrayPerformance::destroy()
+{
+    if(isDestroyed) return;
+    isDestroyed = true;
+    arrayPerformanceThread->destroy();
+    arrayPerformanceThread.reset();
+    PVRecord::destroy();
+}
+
+ArrayPerformanceThread::ArrayPerformanceThread(ArrayPerformancePtr const & arrayPerformance)
+: 
+  arrayPerformance(arrayPerformance),
+  isDestroyed(false),
+  runReturned(false),
+  threadName("arrayPerformance"),
+  value(0)
+{}
+
+void ArrayPerformanceThread::init()
+{
+     thread = std::auto_ptr<epicsThread>(new epicsThread(
+        *this,
+        threadName.c_str(),
+        epicsThreadGetStackSize(epicsThreadStackSmall),
+        epicsThreadPriorityHigh));
+}
+
+void ArrayPerformanceThread::start()
+{
+    thread->start();
+}
+
+void ArrayPerformanceThread::destroy()
+{
+    Lock lock(mutex);
+    if(isDestroyed) return;
+    isDestroyed = true;
+    while(true) {
+        if(runReturned) break;
+        lock.unlock();
+        epicsThreadSleep(.01);
+        lock.lock();
+    }
+    thread->exitWait();
+    thread.reset();
+    arrayPerformance.reset();
+}
+
+void ArrayPerformanceThread::run()
+{
+    TimeStamp timeStamp;
+    TimeStamp timeStampLast;
+    timeStampLast.getCurrent();
+    int nSinceLastReport = 0;
+    while(true) {
+        if(arrayPerformance->delay>0.0) epicsThreadSleep(arrayPerformance->delay);
+        {
+            Lock lock(mutex);
+            if(isDestroyed) {
+                runReturned = true;
+                return;
+            }
+        }
+        timeStamp.getCurrent();
+        double diff = TimeStamp::diff(timeStamp,timeStampLast);
+        if(diff>=1.0) {
+            ostringstream out;
+            out << "arrayPerformance value " << value;
+            out << " time " << diff ;
+            double iterations = nSinceLastReport;
+            iterations /= diff;
+            if(iterations>10.0e9) {
+                 iterations /= 1e9;
+                 out << " gigaIterations/sec " << iterations;
+            } else if(iterations>10.0e6) {
+                 iterations /= 1e6;
+                 out << " megaIterations/sec " << iterations;
+            } else if(iterations>10.0e3) {
+                 iterations /= 1e3;
+                 out << " kiloIterations/sec " << iterations;
+            } else  {
+                 out << " Iterations/sec " << iterations;
+            }
+            double elementSize = arrayPerformance->size;
+            double elementsPerSecond = elementSize*nSinceLastReport;
+            elementsPerSecond /= diff;
+            if(elementsPerSecond>10.0e9) {
+                 elementsPerSecond /= 1e9;
+                 out << " gigaElements/sec " << elementsPerSecond;
+            } else if(elementsPerSecond>10.0e6) {
+                 elementsPerSecond /= 1e6;
+                 out << " megaElements/sec " << elementsPerSecond;
+            } else if(elementsPerSecond>10.0e3) {
+                 elementsPerSecond /= 1e3;
+                 out << " kiloElements/sec " << elementsPerSecond;
+            } else  {
+                 out << " Elements/sec " << elementsPerSecond;
+            }
+            cout << out.str() << endl;
+            timeStampLast = timeStamp;
+            nSinceLastReport = 0;
+        }
+        ++nSinceLastReport;
+        shared_vector<int64> xxx(arrayPerformance->size,value++);
+        shared_vector<const int64> data(freeze(xxx));
+        arrayPerformance->lock();
+        try {
+            arrayPerformance->beginGroupPut();
+            arrayPerformance->pvValue->replace(data);
+            arrayPerformance->process();
+            arrayPerformance->endGroupPut();
+        } catch(...) {
+           arrayPerformance->unlock();
+           throw;
+        }
+        arrayPerformance->unlock();
+    }
+}
+
+}}
+