main addition is array performance example

example/Makefile

@@ -6,6 +6,7 @@ DIRS += pvCopy
 DIRS += exampleCounter
 DIRS += exampleServer
 DIRS += examplePVADoubleArrayGet
+DIRS += arrayPerformance
 DIRS += v3IOC
 include $(TOP)/configure/RULES_DIRS
 

example/arrayPerformance/Makefile

@@ -0,0 +1,20 @@
+TOP=../..
+
+include $(TOP)/configure/CONFIG
+
+PROD_HOST += arrayPerformanceMain
+arrayPerformanceMain_SRCS += arrayPerformanceMain.cpp
+arrayPerformanceMain_LIBS += pvDatabase pvAccess pvData Com
+arrayPerformanceMain_LIBS += pvDatabaseExample
+
+PROD_HOST += longArrayMonitorMain
+longArrayMonitorMain_SRCS += longArrayMonitorMain.cpp
+longArrayMonitorMain_LIBS += pvDatabase pvAccess pvData Com
+longArrayMonitorMain_LIBS += pvDatabaseExample
+
+
+
+include $(TOP)/configure/RULES
+#----------------------------------------
+#  ADD RULES AFTER THIS LINE
+

example/arrayPerformance/arrayPerformanceMain.cpp

@@ -0,0 +1,108 @@
+/*arrayPerformanceMain.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
+ */
+
+/* Author: Marty Kraimer */
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstddef>
+#include <string>
+#include <cstdio>
+#include <memory>
+#include <iostream>
+#include <vector>
+
+#include <pv/standardField.h>
+#include <pv/standardPVField.h>
+#include <pv/arrayPerformance.h>
+#include <pv/longArrayMonitor.h>
+#include <pv/traceRecord.h>
+#include <pv/channelProviderLocal.h>
+#include <pv/serverContext.h>
+#include <pv/clientFactory.h>
+
+using namespace std;
+using std::tr1::static_pointer_cast;
+using namespace epics::pvData;
+using namespace epics::pvAccess;
+using namespace epics::pvDatabase;
+
+int main(int argc,char *argv[])
+{
+    bool result(false);
+    String recordName;
+    recordName = "arrayPerformance";
+    size_t size = 50000000;
+    double delay = .01;
+    String providerName("local");
+    size_t nMonitor = 1;
+    bool useQueue = false;
+    if(argc==2 && String(argv[1])==String("-help")) {
+        cout << "arrayPerformanceMain recordName size";
+        cout << " delay providerName nMonitor useQueue" << endl;
+        cout << "default" << endl;
+        cout << "arrayPerformance ";
+        cout << recordName << " ";
+        cout << size << " ";
+        cout << delay << " ";
+        cout << providerName << " ";
+        cout << nMonitor << " ";
+        cout << (useQueue ? "true" : "false") << endl;
+        return 0;
+    }
+    if(argc>1) recordName = argv[1];
+    if(argc>2) size = strtoul(argv[2],0,0);
+    if(argc>3) delay = atof(argv[3]);
+    if(argc>4) providerName = argv[4];
+    if(argc>5) nMonitor = strtoul(argv[5],0,0);
+    if(argc>6) useQueue = (argv[6]==String("true") ? true : false);
+    cout << "arrayPerformance ";
+    cout << recordName << " ";
+    cout << size << " ";
+    cout << delay << " ";
+    cout << providerName << " ";
+    cout << nMonitor << " ";
+    cout << (useQueue ? "true" : "false") << endl;
+    ClientFactory::start();
+    PVDatabasePtr master = PVDatabase::getMaster();
+    ChannelProviderLocalPtr channelProvider = getChannelProviderLocal();
+    PVRecordPtr pvRecord;
+    pvRecord = ArrayPerformance::create(recordName,size,delay);
+    result = master->addRecord(pvRecord);
+    pvRecord = TraceRecord::create("traceRecordPGRPC");
+    result = master->addRecord(pvRecord);
+    if(!result) cout<< "record " << recordName << " not added" << endl;
+    pvRecord.reset();
+    ServerContext::shared_pointer pvaServer = 
+        startPVAServer(PVACCESS_ALL_PROVIDERS,0,true,true);
+    std::vector<LongArrayMonitorPtr> longArrayMonitor(nMonitor);
+    for(size_t i=0; i<nMonitor; ++i) {
+       longArrayMonitor[i]
+         = LongArrayMonitor::create(providerName,recordName,useQueue);
+    }
+    for(size_t i=0; i<nMonitor; ++i) longArrayMonitor[i]->start();
+    cout << "arrayPerformance\n";
+    string str;
+    while(true) {
+        cout << "Type exit to stop: \n";
+        getline(cin,str);
+        if(str.compare("exit")==0) break;
+
+    }
+    for(size_t i=0; i<nMonitor; ++i) longArrayMonitor[i]->stop();
+    pvaServer->shutdown();
+    epicsThreadSleep(1.0);
+    pvaServer->destroy();
+    ClientFactory::stop();
+    channelProvider->destroy();
+    return 0;
+}
+

example/arrayPerformance/longArrayMonitorMain.cpp

@@ -0,0 +1,70 @@
+/*longArrayMonitorMain.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.10
+ */
+
+/* Author: Marty Kraimer */
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstddef>
+#include <string>
+#include <cstdio>
+#include <memory>
+#include <iostream>
+#include <vector>
+
+#include <pv/standardField.h>
+#include <pv/standardPVField.h>
+#include <pv/arrayPerformance.h>
+#include <pv/longArrayMonitor.h>
+#include <pv/traceRecord.h>
+#include <pv/channelProviderLocal.h>
+#include <pv/serverContext.h>
+#include <pv/clientFactory.h>
+
+using namespace std;
+using std::tr1::static_pointer_cast;
+using namespace epics::pvData;
+using namespace epics::pvAccess;
+using namespace epics::pvDatabase;
+
+int main(int argc,char *argv[])
+{
+    String channelName("arrayPerformance");
+    bool useQueue = false;
+    if(argc==2 && String(argv[1])==String("-help")) {
+        cout << "longArrayMonitorMain channelName useQueue" << endl;
+        cout << "default" << endl;
+        cout << "longArrayMonitorMain " << channelName << " ";
+        cout << (useQueue ? "true" : "false") << endl;
+        return 0;
+    }
+    ClientFactory::start();
+    if(argc>1) channelName = argv[1];
+    if(argc>2) useQueue = (String(argv[2])==String("true") ? true : false);
+    cout << "longArrayMonitorMain " << channelName << " ";
+    cout << (useQueue ? "true" : "false") << endl;
+    LongArrayMonitorPtr longArrayMonitor
+         = LongArrayMonitor::create("pvAccess",channelName,useQueue);
+    longArrayMonitor->start();
+    cout << "longArrayMonitor\n";
+    string str;
+    while(true) {
+        cout << "Type exit to stop: \n";
+        getline(cin,str);
+        if(str.compare("exit")==0) break;
+
+    }
+    longArrayMonitor->destroy();
+    longArrayMonitor.reset();
+    ClientFactory::stop();
+    return 0;
+}
+

example/exampleCounter/exampleCounterMain.cpp

@@ -47,7 +47,8 @@ int main(int argc,char *argv[])
     result = master->addRecord(pvRecord);
     if(!result) cout<< "record " << recordName << " not added" << endl;
     pvRecord.reset();
-    startPVAServer(PVACCESS_ALL_PROVIDERS,0,true,true);
+    ServerContext::shared_pointer pvaServer = 
+        startPVAServer(PVACCESS_ALL_PROVIDERS,0,true,true);
     cout << "exampleCounter\n";
     string str;
     while(true) {
@@ -56,6 +57,10 @@ int main(int argc,char *argv[])
         if(str.compare("exit")==0) break;
 
     }
+    pvaServer->shutdown();
+    epicsThreadSleep(1.0);
+    pvaServer->destroy();
+    channelProvider->destroy();
     return 0;
 }
 

example/pvCopy/testPVCopy.cpp

@@ -116,7 +116,6 @@ static void testPVScalar(
     size_t offset;
     ConvertPtr convert = getConvert();
 
-    pvRecord->lock_guard();
     cout << endl;
     pvStructureRecord = pvRecord->getPVRecordStructure()->getPVStructure();
     pvField = pvStructureRecord->getSubField(valueNameRecord);
@@ -129,11 +128,11 @@ static void testPVScalar(
     pvField = pvStructureCopy->getSubField(valueNameCopy);
     pvValueCopy = static_pointer_cast<PVScalar>(pvField);
     bitSet = BitSetPtr(new BitSet(pvStructureCopy->getNumberFields()));
-    pvCopy->initCopy(pvStructureCopy, bitSet, true);
+    pvCopy->initCopy(pvStructureCopy, bitSet);
     cout << "after initCopy pvValueCopy " << convert->toDouble(pvValueCopy);
     cout << endl;
     convert->fromDouble(pvValueRecord,.06);
-    pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet,true);
+    pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet);
     cout << "after put(.06) pvValueCopy " << convert->toDouble(pvValueCopy);
     builder.clear();
     bitSet->toString(&builder);
@@ -156,7 +155,7 @@ static void testPVScalar(
     cout << " bitSet " << builder;
     cout << endl;
     bitSet->set(0);
-    pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet,true);
+    pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet);
     cout << "after updateCopyFromBitSet";
     cout << " recordValue " << convert->toDouble(pvValueRecord);
     cout << " copyValue " << convert->toDouble(pvValueCopy);
@@ -169,7 +168,7 @@ static void testPVScalar(
     cout << " copyValue " << convert->toDouble(pvValueCopy);
     cout << " bitSet " << builder;
     cout << endl;
-    pvCopy->updateRecord(pvStructureCopy,bitSet,true);
+    pvCopy->updateRecord(pvStructureCopy,bitSet);
     cout << "after updateRecord";
     cout << " recordValue " << convert->toDouble(pvValueRecord);
     cout << " copyValue " << convert->toDouble(pvValueCopy);
@@ -194,7 +193,6 @@ static void testPVScalarArray(
     size_t offset;
     size_t n = 5;
     shared_vector<double> values(n);
-    pvRecord->lock_guard();
     cout << endl;
     pvStructureRecord = pvRecord->getPVRecordStructure()->getPVStructure();
     pvValueRecord = pvStructureRecord->getScalarArrayField(valueNameRecord,scalarType);
@@ -207,7 +205,7 @@ static void testPVScalarArray(
     pvStructureCopy = pvCopy->createPVStructure();
     pvValueCopy = pvStructureCopy->getScalarArrayField(valueNameCopy,scalarType);
     bitSet = BitSetPtr(new BitSet(pvStructureCopy->getNumberFields()));
-    pvCopy->initCopy(pvStructureCopy, bitSet, true);
+    pvCopy->initCopy(pvStructureCopy, bitSet);
     builder.clear(); pvValueCopy->toString(&builder);
     cout << "after initCopy pvValueCopy " << builder << endl;
     cout << endl;
@@ -215,7 +213,7 @@ static void testPVScalarArray(
     for(size_t i=0; i<n; i++) values[i] = i + .06;
     const shared_vector<const double> yyy(freeze(values));
     pvValueRecord->putFrom(yyy);
-    pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet,true);
+    pvCopy->updateCopySetBitSet(pvStructureCopy,bitSet);
     builder.clear(); pvValueCopy->toString(&builder);
     cout << "after put(i+ .06) pvValueCopy " << builder << endl;
     builder.clear();
@@ -248,7 +246,7 @@ static void testPVScalarArray(
     bitSet->toString(&builder);
     cout << endl;
     bitSet->set(0);
-    pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet,true);
+    pvCopy->updateCopyFromBitSet(pvStructureCopy,bitSet);
     cout << "after updateCopyFromBitSet";
     builder.clear(); pvValueRecord->toString(&builder);
     cout << " recordValue " << builder << endl;
@@ -272,7 +270,7 @@ static void testPVScalarArray(
     bitSet->toString(&builder);
     cout << " bitSet " << builder;
     cout << endl;
-    pvCopy->updateRecord(pvStructureCopy,bitSet,true);
+    pvCopy->updateRecord(pvStructureCopy,bitSet);
     cout << "after updateRecord";
     builder.clear(); pvValueRecord->toString(&builder);
     cout << " recordValue " << builder << endl;

example/record/testExampleRecordMain.cpp

@@ -64,7 +64,7 @@ static PVStructurePtr createPowerSupply()
 }
 
 
-int main(int argc,char *argv[])
+void test()
 {
     StandardPVFieldPtr standardPVField = getStandardPVField();
     String properties;
@@ -77,11 +77,13 @@ int main(int argc,char *argv[])
     pvStructure = standardPVField->scalar(scalarType,properties);
     PVRecordPtr pvRecord = PVRecord::create(recordName,pvStructure);
     {
-        pvRecord->lock_guard();
+        pvRecord->lock();
         pvRecord->process();
+        pvRecord->unlock();
     }
     cout << "processed exampleDouble "  << endl;
     pvRecord->destroy();
+    pvRecord.reset();
     recordName = "powerSupplyExample";
     pvStructure.reset();
     pvStructure = createPowerSupply();
@@ -89,14 +91,16 @@ int main(int argc,char *argv[])
         PowerSupplyRecordTest::create(recordName,pvStructure);
     if(psr.get()==NULL) {
         cout << "PowerSupplyRecordTest::create failed" << endl;
-        return 1;
+        return;
     }
+    pvStructure.reset();
     double voltage,power,current;
     {
-        psr->lock_guard();
+        psr->lock();
         voltage = psr->getVoltage();
         power = psr->getPower();
         current = psr->getCurrent();
+        psr->unlock();
     }
     cout << "initial ";
     cout << " voltage " << voltage ;
@@ -110,21 +114,29 @@ int main(int argc,char *argv[])
     cout << " power " << power;
     cout << endl;
     {
-        psr->lock_guard();
+        psr->lock();
         psr->put(power,voltage);
         psr->process();
+        psr->unlock();
     }
     {
-        psr->lock_guard();
+        psr->lock();
         cout << "after put ";
         cout << " voltage " << psr->getVoltage() ;
         cout << " power " << psr->getPower();
         cout <<  " current " << psr->getCurrent();
         cout << endl;
+        psr->unlock();
     }
     PVDatabasePtr pvDatabase = PVDatabase::getMaster();
     pvDatabase->addRecord(psr);
+    psr.reset();
     pvDatabase->destroy();
+}
+
+int main(int argc,char *argv[])
+{
+    test();
     return 0;
 }
 

example/src/Makefile

@@ -18,6 +18,12 @@ SRC_DIRS += $(EXAMPLESRC)/examplePVADoubleArrayGet
 INC+= examplePVADoubleArrayGet.h
 LIBSRCS += examplePVADoubleArrayGet.cpp
 
+SRC_DIRS += $(EXAMPLESRC)/arrayPerformance
+INC+= arrayPerformance.h
+LIBSRCS += arrayPerformance.cpp
+INC+= longArrayMonitor.h
+LIBSRCS += longArrayMonitor.cpp
+
 
 include $(TOP)/configure/RULES
 

example/src/arrayPerformance/arrayPerformance.cpp

@@ -0,0 +1,173 @@
+/* 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;
+
+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")
+{}
+
+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) {
+            cout << "arrayPerformance value " << value;
+            cout << " time " << diff;
+            double iterations = nSinceLastReport;
+            iterations /= diff;
+            cout << " iterations/sec " << iterations;
+            double elementSize = arrayPerformance->size;
+            double elementsPerSecond = elementSize*nSinceLastReport;
+            elementsPerSecond /= diff;
+            elementsPerSecond /= 1e6;
+            cout << " elements/sec " << elementsPerSecond << "million" << endl;
+            cout.flush();
+            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();
+    }
+}
+
+}}
+

example/src/arrayPerformance/arrayPerformance.h

@@ -0,0 +1,80 @@
+/* arrayPerformance.h */
+/**
+ * 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
+ */
+#ifndef ARRAYPERFORMANCE_H
+#define ARRAYPERFORMANCE_H
+
+#include <epicsThread.h>
+#include <pv/standardPVField.h>
+#include <pv/timeStamp.h>
+#include <pv/pvTimeStamp.h>
+#include <pv/pvDatabase.h>
+
+namespace epics { namespace pvDatabase { 
+
+class ArrayPerformance;
+typedef std::tr1::shared_ptr<ArrayPerformance> ArrayPerformancePtr;
+
+class ArrayPerformanceThread;
+typedef std::tr1::shared_ptr<ArrayPerformanceThread> ArrayPerformanceThreadPtr;
+
+class ArrayPerformance :
+    public PVRecord
+{
+public:
+    POINTER_DEFINITIONS(ArrayPerformance);
+    static ArrayPerformancePtr create(
+        epics::pvData::String const & recordName,
+        size_t size,
+        double delay);
+    virtual ~ArrayPerformance();
+    virtual bool init();
+    virtual void start();
+    virtual void process();
+    virtual void destroy();
+private:
+    ArrayPerformance(epics::pvData::String const & recordName,
+        epics::pvData::PVStructurePtr const & pvStructure,
+        size_t size,
+        double delay);
+    size_t size;
+    double delay;
+    bool isDestroyed;
+    epics::pvData::PVLongArrayPtr pvValue;
+    epics::pvData::PVTimeStamp pvTimeStamp;
+    epics::pvData::TimeStamp timeStamp;
+    ArrayPerformanceThreadPtr arrayPerformanceThread;
+    friend class ArrayPerformanceThread;
+};
+
+class ArrayPerformanceThread :
+   public epicsThreadRunable
+{
+public:
+    ArrayPerformanceThread(ArrayPerformancePtr const & arrayPerformance);
+    virtual ~ArrayPerformanceThread(){};
+    void init();
+    void start();
+    virtual void run();
+    void destroy();
+private:
+    ArrayPerformancePtr arrayPerformance;
+    bool isDestroyed;
+    bool runReturned;
+    epics::pvData::String threadName;
+    epics::pvData::Mutex mutex;
+    epics::pvData::int64 value;
+    std::auto_ptr<epicsThread> thread;
+};
+
+
+}}
+
+#endif  /* ARRAYPERFORMANCE_H */

example/src/arrayPerformance/longArrayMonitor.cpp

@@ -0,0 +1,284 @@
+/* longArrayMonitor.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.09
+ */
+
+#include <epicsThread.h>
+#include <pv/longArrayMonitor.h>
+#include <pv/caProvider.h>
+
+namespace epics { namespace pvDatabase { 
+
+using namespace epics::pvData;
+using namespace epics::pvAccess;
+using std::tr1::static_pointer_cast;
+using std::tr1::dynamic_pointer_cast;
+using std::cout;
+using std::endl;
+
+static String requesterName("longArrayMonitor");
+
+static void messagePvt(String const & message, MessageType messageType)
+{
+    cout << requesterName << " message " << message << endl;
+}
+
+class LAMChannelRequester :
+    public ChannelRequester
+{
+public:
+    LAMChannelRequester(LongArrayMonitorPtr const &longArrayMonitor)
+    : longArrayMonitor(longArrayMonitor)
+    {}
+    virtual ~LAMChannelRequester(){}
+    virtual String getRequesterName() { return requesterName;}
+    virtual void message(String const & message, MessageType messageType)
+       { messagePvt(message,messageType);}
+    virtual void channelCreated(const Status& status, Channel::shared_pointer const & channel);
+    virtual void channelStateChange(Channel::shared_pointer const & channel, Channel::ConnectionState connectionState);
+private:
+    LongArrayMonitorPtr longArrayMonitor;
+};
+
+void LAMChannelRequester::channelCreated(const Status& status, Channel::shared_pointer const & channel)
+{
+    if(!status.isOK()) messagePvt(status.getMessage(),errorMessage);
+    longArrayMonitor->status = status;
+    longArrayMonitor->channel = channel;
+    longArrayMonitor->event.signal();
+}
+
+void LAMChannelRequester::channelStateChange(Channel::shared_pointer const & channel, Channel::ConnectionState connectionState)
+{
+   MessageType messageType = (connectionState==Channel::CONNECTED ? infoMessage : errorMessage);
+   messagePvt("channelStateChange",messageType);
+}
+
+
+class LAMMonitorRequester :
+    public MonitorRequester,
+    public epicsThreadRunable
+{
+public:
+    LAMMonitorRequester(LongArrayMonitorPtr const &longArrayMonitor)
+    : longArrayMonitor(longArrayMonitor),
+      isDestroyed(false),
+      runReturned(false),
+      threadName("longArrayMonitor")
+    {}
+    virtual ~LAMMonitorRequester(){}
+    void init();
+    virtual void destroy();
+    virtual void run();
+    virtual String getRequesterName() { return requesterName;}
+    virtual void message(String const & message, MessageType messageType)
+       { messagePvt(message,messageType);}
+    virtual void monitorConnect(Status const & status,
+        MonitorPtr const & monitor, StructureConstPtr const & structure);
+    virtual void monitorEvent(MonitorPtr const & monitor);
+    virtual void unlisten(MonitorPtr const & monitor);
+private:
+    void handleMonitor();
+    LongArrayMonitorPtr longArrayMonitor;
+    bool isDestroyed;
+    bool runReturned;
+    epics::pvData::String threadName;
+    Event event;
+    std::auto_ptr<epicsThread> thread;
+};
+
+void LAMMonitorRequester::init()
+{
+     thread = std::auto_ptr<epicsThread>(new epicsThread(
+        *this,
+        threadName.c_str(),
+        epicsThreadGetStackSize(epicsThreadStackSmall),
+        epicsThreadPriorityLow));
+     thread->start();
+}
+
+void LAMMonitorRequester::destroy()
+{
+    if(isDestroyed) return;
+    isDestroyed = true;
+    event.signal();
+    while(true) {
+        if(runReturned) break;
+        epicsThreadSleep(.01);
+    }
+    thread->exitWait();
+    longArrayMonitor.reset();
+}
+
+
+void LAMMonitorRequester::monitorConnect(Status const & status,
+        MonitorPtr const & monitor, StructureConstPtr const & structure)
+{
+    longArrayMonitor->status = status;
+    longArrayMonitor->monitor = monitor;
+    if(!status.isOK())  {
+        messagePvt(status.getMessage(),errorMessage);
+        longArrayMonitor->event.signal();
+        return;
+    }
+    bool structureOK(true);
+    FieldConstPtr field = structure->getField("timeStamp");
+    if(field==NULL) structureOK = false;
+    field = structure->getField("value");
+    if(field==NULL) {
+         structureOK = false;
+    } else {
+        if(field->getType()!=scalarArray) {
+            structureOK = false; 
+        } else {
+            ScalarArrayConstPtr scalarArray = dynamic_pointer_cast<const ScalarArray>(field);
+            if(scalarArray->getElementType()!=pvLong) structureOK = false;
+        }
+    }
+    if(!structureOK) {
+        String message("monitorConnect: illegal structure");
+        messagePvt(message,errorMessage);
+        longArrayMonitor->status = Status(Status::STATUSTYPE_ERROR,message);
+    }
+    longArrayMonitor->event.signal();
+}
+
+void LAMMonitorRequester::run()
+{
+    PVLongArrayPtr pvValue;
+    PVTimeStamp pvTimeStamp;
+    TimeStamp timeStamp;
+    TimeStamp timeStampLast;
+    timeStampLast.getCurrent();
+    while(true) {
+        event.wait();
+        if(isDestroyed) {
+            runReturned = true;
+            return;
+        }
+        while(true) {
+            MonitorElementPtr monitorElement = longArrayMonitor->monitor->poll();
+            if(monitorElement==NULL) break;
+            PVStructurePtr pvStructure = monitorElement->pvStructurePtr;
+            pvTimeStamp.attach(pvStructure->getSubField("timeStamp"));
+            pvTimeStamp.get(timeStamp);
+            pvValue = dynamic_pointer_cast<PVLongArray>(pvStructure->getSubField("value"));
+            shared_vector<const int64> data = pvValue->view();
+            if(data.size()>0) {
+                int64 first = data[0];
+                int64 last = data[data.size()-1];
+                int64 sum = 0;
+                for(size_t i=0; i<data.size(); ++i) sum += data[i];
+                double diff = TimeStamp::diff(timeStamp,timeStampLast);
+                double elementsPerSecond = data.size();
+                elementsPerSecond = 1e-6*elementsPerSecond/diff;
+                cout.flush();
+                cout << "first " << first << " last " << last << " sum " << sum;
+                cout << " elements/sec " << elementsPerSecond << "million";
+                BitSetPtr changed = monitorElement->changedBitSet;
+                BitSetPtr overrun = monitorElement->overrunBitSet;
+                String buffer;
+                changed->toString(&buffer);
+                cout << " changed " << buffer;
+                buffer.clear();
+                overrun->toString(&buffer);
+                cout << " overrun " << buffer;
+                cout << endl;
+                cout.flush();
+                timeStampLast = timeStamp;
+            } else {
+                cout << "size = 0" << endl;
+            }
+            longArrayMonitor->monitor->release(monitorElement);
+        }
+    }
+}
+
+void LAMMonitorRequester::monitorEvent(MonitorPtr const & monitor)
+{
+    event.signal();
+}
+
+void LAMMonitorRequester::unlisten(MonitorPtr const & monitor)
+{
+    messagePvt("unlisten called",errorMessage);
+}
+
+
+LongArrayMonitorPtr LongArrayMonitor::create(
+    String const &providerName,
+    String const & channelName,
+    bool useQueue)
+{
+    LongArrayMonitorPtr longArrayMonitor(new LongArrayMonitor());
+    if(!longArrayMonitor->init(providerName,channelName,useQueue)) longArrayMonitor.reset();
+    return longArrayMonitor;
+}
+
+LongArrayMonitor::LongArrayMonitor() {}
+
+LongArrayMonitor::~LongArrayMonitor() {}
+
+bool LongArrayMonitor::init(
+    String const &providerName,
+    String const &channelName,
+    bool useQueue)
+{
+    channelRequester = LAMChannelRequesterPtr(new LAMChannelRequester(getPtrSelf()));
+    monitorRequester = LAMMonitorRequesterPtr(new LAMMonitorRequester(getPtrSelf()));
+    monitorRequester->init();
+    ChannelProvider::shared_pointer channelProvider = getChannelAccess()->getProvider(providerName);
+    if(channelProvider==NULL) {
+        cout << "provider " << providerName << " not found" << endl;
+        return false;
+    }
+    channel = channelProvider->createChannel(channelName,channelRequester,0);
+    event.wait();
+    if(!status.isOK()) return false;
+    String queueSize("0");
+    if(useQueue) queueSize="2";
+    String request("record[queueSize=");
+    request += queueSize;
+    request += "]field(value,timeStamp,alarm)";
+    PVStructurePtr pvRequest =
+        getCreateRequest()->createRequest(request,channelRequester);
+    if(pvRequest==NULL) {
+        cout << "request logic error " << request << endl;
+        return false;
+    }
+    monitor = channel->createMonitor(monitorRequester,pvRequest);
+    event.wait();
+    if(!status.isOK()) return false;
+    return true;
+}
+
+void LongArrayMonitor::start()
+{
+    monitor->start();
+}
+
+void LongArrayMonitor::stop()
+{
+    monitor->stop();
+}
+
+void LongArrayMonitor::destroy()
+{
+    monitorRequester->destroy();
+    monitorRequester.reset();
+    monitor->destroy();
+    monitor.reset();
+    channel->destroy();
+    channel.reset();
+    channelRequester.reset();
+}
+
+}}
+
+

example/src/arrayPerformance/longArrayMonitor.h

@@ -0,0 +1,71 @@
+/* longArrayMonitor.h */
+/**
+ * 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.09
+ */
+#ifndef LONGARRAYMONITOR_H
+#define LONGARRAYMONITOR_H
+
+#include <pv/event.h>
+#include <pv/lock.h>
+#include <pv/standardPVField.h>
+#include <pv/timeStamp.h>
+#include <pv/pvTimeStamp.h>
+#include <pv/pvAccess.h>
+
+namespace epics { namespace pvDatabase { 
+
+
+class LongArrayMonitor;
+typedef std::tr1::shared_ptr<LongArrayMonitor> LongArrayMonitorPtr;
+
+class LAMChannelRequester;
+typedef std::tr1::shared_ptr<LAMChannelRequester> LAMChannelRequesterPtr;
+
+class LAMMonitorRequester;
+typedef std::tr1::shared_ptr<LAMMonitorRequester> LAMMonitorRequesterPtr;
+
+class LongArrayMonitor :
+    public std::tr1::enable_shared_from_this<LongArrayMonitor>
+{
+public:
+    POINTER_DEFINITIONS(LongArrayMonitor);
+    static LongArrayMonitorPtr create(
+        epics::pvData::String const & providerName,
+        epics::pvData::String const & channelName,
+        bool useQueue = false);
+    ~LongArrayMonitor();
+    void start();
+    void stop();
+    void destroy();
+private:
+    static epics::pvData::Mutex printMutex;
+    bool init(
+        epics::pvData::String const & providerName,
+        epics::pvData::String const & channelName,
+        bool useQueue);
+    LongArrayMonitorPtr getPtrSelf()
+    {
+        return shared_from_this();
+    }
+    LongArrayMonitor();
+
+    LAMChannelRequesterPtr channelRequester;
+    LAMMonitorRequesterPtr monitorRequester;
+    epics::pvAccess::Channel::shared_pointer channel;
+    epics::pvData::Monitor::shared_pointer monitor;
+    epics::pvData::Event event;
+    epics::pvData::Status status;
+    friend class LAMChannelRequester;
+    friend class LAMMonitorRequester;
+};
+
+
+}}
+
+#endif  /* LONGARRAYMONITOR_H */

example/src/examplePVADoubleArrayGet/examplePVADoubleArrayGet.h

@@ -70,7 +70,6 @@ private:
     epics::pvData::Alarm alarm;
     epics::pvAccess::Channel::shared_pointer channel;
     epics::pvAccess::ChannelGet::shared_pointer channelGet;
-    epics::pvData::Mutex mutex;
     epics::pvData::Event event;
     epics::pvData::Status status;
     epics::pvData::PVStructurePtr getPVStructure;