added longArrayGet and longArrayPut; much more testing

example/arrayPerformance/Makefile

@@ -12,6 +12,16 @@ longArrayMonitorMain_SRCS += longArrayMonitorMain.cpp
 longArrayMonitorMain_LIBS += pvDatabase pvAccess pvData Com
 longArrayMonitorMain_LIBS += pvDatabaseExample
 
+PROD_HOST += longArrayGetMain
+longArrayGetMain_SRCS += longArrayGetMain.cpp
+longArrayGetMain_LIBS += pvDatabase pvAccess pvData Com
+longArrayGetMain_LIBS += pvDatabaseExample
+
+PROD_HOST += longArrayPutMain
+longArrayPutMain_SRCS += longArrayPutMain.cpp
+longArrayPutMain_LIBS += pvDatabase pvAccess pvData Com
+longArrayPutMain_LIBS += pvDatabaseExample
+
 PROD_HOST += vectorPerformanceMain
 vectorPerformanceMain_SRCS += vectorPerformanceMain.cpp
 vectorPerformanceMain_LIBS += pvDatabase pvAccess pvData Com

example/arrayPerformance/longArrayGetMain.cpp

@@ -0,0 +1,86 @@
+/*longArrayGetMain.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/longArrayGet.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");
+    int iterBetweenCreateChannel = 0;
+    int iterBetweenCreateChannelGet = 0;
+    double delayTime = 1.0;
+    if(argc==2 && String(argv[1])==String("-help")) {
+        cout << "longArrayGetMain channelName ";
+        cout << "iterBetweenCreateChannel iterBetweenCreateChannelGet delayTime" << endl;
+        cout << "default" << endl;
+        cout << "longArrayGetMain " << channelName << " ";
+        cout << iterBetweenCreateChannel  << " ";
+        cout << iterBetweenCreateChannelGet  << " ";
+        cout << delayTime  << endl;
+        return 0;
+    }
+    ClientFactory::start();
+    if(argc>1) channelName = argv[1];
+    if(argc>2) iterBetweenCreateChannel = strtol(argv[2],0,0);
+    if(argc>3) iterBetweenCreateChannelGet = strtol(argv[3],0,0);
+    if(argc>4) delayTime = atof(argv[4]);
+    cout << "longArrayGetMain " << channelName << " ";
+    cout << iterBetweenCreateChannel  << " ";
+    cout << iterBetweenCreateChannelGet  << " ";
+    cout << delayTime << endl;
+    LongArrayGetPtr longArrayGet
+         = LongArrayGet::create(
+              "pvAccess",
+              channelName,
+              iterBetweenCreateChannel,
+              iterBetweenCreateChannelGet,
+              delayTime);
+    cout << "longArrayGet\n";
+    string str;
+    while(true) {
+        cout << "Type exit to stop: \n";
+        getline(cin,str);
+        if(str.compare("exit")==0) break;
+
+    }
+    longArrayGet->destroy();
+    longArrayGet.reset();
+    double xxx = 1.0;
+    if(xxx<delayTime) xxx = delayTime;
+    ClientFactory::stop();
+    epicsThreadSleep(xxx);
+    return 0;
+}
+

example/arrayPerformance/longArrayMonitorMain.cpp

@@ -66,10 +66,10 @@ int main(int argc,char *argv[])
         if(str.compare("exit")==0) break;
 
     }
-    ClientFactory::stop();
-    epicsThreadSleep(.1);
     longArrayMonitor->destroy();
     longArrayMonitor.reset();
+    ClientFactory::stop();
+    epicsThreadSleep(1.0);
     return 0;
 }
 

example/arrayPerformance/longArrayPutMain.cpp

@@ -0,0 +1,92 @@
+/*longArrayPutMain.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/longArrayPut.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");
+    size_t arraySize = 10;
+    int iterBetweenCreateChannel = 0;
+    int iterBetweenCreateChannelPut = 0;
+    double delayTime = 1.0;
+    if(argc==2 && String(argv[1])==String("-help")) {
+        cout << "longArrayPutMain channelName arraySize ";
+        cout << "iterBetweenCreateChannel iterBetweenCreateChannelPut delayTime" << endl;
+        cout << "default" << endl;
+        cout << "longArrayPutMain " << channelName << " ";
+        cout << arraySize << " ";
+        cout << iterBetweenCreateChannel  << " ";
+        cout << iterBetweenCreateChannelPut  << " ";
+        cout << delayTime  << endl;
+        return 0;
+    }
+    ClientFactory::start();
+    if(argc>1) channelName = argv[1];
+    if(argc>2) arraySize = strtoul(argv[2],0,0);
+    if(argc>3) iterBetweenCreateChannel = strtol(argv[3],0,0);
+    if(argc>4) iterBetweenCreateChannelPut = strtol(argv[4],0,0);
+    if(argc>5) delayTime = atof(argv[5]);
+    cout << "longArrayPutMain " << channelName << " ";
+    cout << arraySize << " ";
+    cout << iterBetweenCreateChannel  << " ";
+    cout << iterBetweenCreateChannelPut  << " ";
+    cout << delayTime << endl;
+    LongArrayPutPtr longArrayPut
+         = LongArrayPut::create(
+              "pvAccess",
+              channelName,
+              arraySize,
+              iterBetweenCreateChannel,
+              iterBetweenCreateChannelPut,
+              delayTime);
+    cout << "longArrayPut\n";
+    string str;
+    while(true) {
+        cout << "Type exit to stop: \n";
+        getline(cin,str);
+        if(str.compare("exit")==0) break;
+
+    }
+    longArrayPut->destroy();
+    longArrayPut.reset();
+    double xxx = 1.0;
+    if(xxx<delayTime) xxx = delayTime;
+    epicsThreadSleep(xxx);
+    ClientFactory::stop();
+    epicsThreadSleep(1.0);
+    return 0;
+}
+

example/src/Makefile

@@ -23,6 +23,10 @@ INC+= arrayPerformance.h
 LIBSRCS += arrayPerformance.cpp
 INC+= longArrayMonitor.h
 LIBSRCS += longArrayMonitor.cpp
+INC+= longArrayGet.h
+LIBSRCS += longArrayGet.cpp
+INC+= longArrayPut.h
+LIBSRCS += longArrayPut.cpp
 
 
 include $(TOP)/configure/RULES

example/src/arrayPerformance/arrayPerformance.cpp

@@ -143,15 +143,36 @@ void ArrayPerformanceThread::run()
         if(diff>=1.0) {
             ostringstream out;
             out << "arrayPerformance value " << value;
-            out << " time " << diff;
+            out << " time " << diff ;
             double iterations = nSinceLastReport;
             iterations /= diff;
-            out << " iterations/sec " << iterations;
+            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;
-            elementsPerSecond /= 1e6;
-            out << " elements/sec " << elementsPerSecond << "million";
+            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;

example/src/arrayPerformance/longArrayGet.cpp

@@ -0,0 +1,381 @@
+/* longArrayGet.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/longArrayGet.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;
+using std::ostringstream;
+
+static String requesterName("longArrayGet");
+static String request("value,timeStamp,alarm");
+static epics::pvData::Mutex printMutex;
+
+class LongArrayChannelGet :
+    virtual public ChannelRequester,
+    virtual public ChannelGetRequester,
+    public std::tr1::enable_shared_from_this<LongArrayChannelGet>,
+    public epicsThreadRunable
+{
+public:
+    LongArrayChannelGet(
+        String providerName,
+        String channelName,
+        int iterBetweenCreateChannel,
+        int iterBetweenCreateChannelGet,
+        double delayTime)
+    : providerName(providerName),
+      channelName(channelName),
+      iterBetweenCreateChannel(iterBetweenCreateChannel),
+      iterBetweenCreateChannelGet(iterBetweenCreateChannelGet),
+      delayTime(delayTime),
+      isDestroyed(false),
+      runReturned(false),
+      threadName("longArrayGet")
+    {}
+    virtual ~LongArrayChannelGet(){}
+    bool init();
+    virtual void destroy();
+    virtual void run();
+    virtual String getRequesterName() { return requesterName;}
+    virtual void message(String const & message, MessageType messageType)
+       {
+            Lock guard(printMutex);
+            cout << requesterName << " message " << message << endl;
+       }
+    virtual void channelCreated(
+        const Status& status,
+        Channel::shared_pointer const & channel);
+    virtual void channelStateChange(
+        Channel::shared_pointer const & channel,
+        Channel::ConnectionState connectionState);
+    virtual void channelGetConnect(
+        Status const & status,
+        ChannelGet::shared_pointer const & channelGet,
+        PVStructurePtr const &pvStructure,
+        BitSetPtr const &bitSet);
+    virtual void getDone(Status const & status);
+private:
+    LongArrayChannelGetPtr getPtrSelf()
+    {
+        return shared_from_this();
+    }
+    size_t checkResult();
+    String providerName;
+    String channelName;
+    int iterBetweenCreateChannel;
+    int iterBetweenCreateChannelGet;
+    double delayTime;
+    bool isDestroyed;
+    bool runReturned;
+    epics::pvData::String threadName;
+    Status status;
+    Event event;
+    Mutex mutex;
+    std::auto_ptr<epicsThread> thread;
+    Channel::shared_pointer channel;
+    ChannelGet::shared_pointer channelGet;
+    PVStructurePtr pvStructure;
+    BitSetPtr bitSet;
+};
+
+bool LongArrayChannelGet::init()
+{
+    ChannelProvider::shared_pointer channelProvider =
+        getChannelAccess()->getProvider(providerName);
+    if(channelProvider==NULL) {
+        cout << "provider " << providerName << " not found" << endl;
+        return false;
+    }
+    channel = channelProvider->createChannel(channelName,getPtrSelf(),0);
+    event.wait();
+    channelProvider.reset();
+    if(!status.isOK()) return false;
+    CreateRequest::shared_pointer createRequest = CreateRequest::create();
+    PVStructurePtr pvRequest = createRequest->createRequest(request);
+    if(pvRequest==NULL) {
+        cout << "request logic error " << createRequest->getMessage() << endl;
+        return false;
+    }
+    channelGet = channel->createChannelGet(getPtrSelf(),pvRequest);
+    event.wait();
+    if(!status.isOK()) return false;
+     thread = std::auto_ptr<epicsThread>(new epicsThread(
+        *this,
+        threadName.c_str(),
+        epicsThreadGetStackSize(epicsThreadStackSmall),
+        epicsThreadPriorityLow));
+     thread->start();
+     event.signal();
+     return true;
+}
+
+void LongArrayChannelGet::destroy()
+{
+    if(isDestroyed) return;
+    isDestroyed = true;
+    event.signal();
+    while(true) {
+        if(runReturned) break;
+        epicsThreadSleep(.01);
+    }
+    thread->exitWait();
+    channel->destroy();
+    channelGet.reset();
+    channel.reset();
+}
+
+void LongArrayChannelGet::channelCreated(
+    const Status& status,
+    Channel::shared_pointer const & channel)
+{
+    if(!status.isOK()) message(status.getMessage(),errorMessage);
+    this->status = status;
+    this->channel = channel;
+    event.signal();
+}
+
+void LongArrayChannelGet::channelStateChange(
+    Channel::shared_pointer const & channel,
+    Channel::ConnectionState connectionState)
+{
+   MessageType messageType =
+       (connectionState==Channel::CONNECTED ? infoMessage : errorMessage);
+   message("channelStateChange",messageType);
+}
+
+
+void LongArrayChannelGet::channelGetConnect(
+        Status const & status,
+        ChannelGet::shared_pointer const & channelGet,
+        PVStructurePtr const &pvStructure,
+        BitSetPtr const &bitSet)
+{
+    this->status = status;
+    if(!status.isOK())  {
+        message(status.getMessage(),errorMessage);
+        event.signal();
+        return;
+    }
+    this->channelGet = channelGet;
+    this->pvStructure = pvStructure;
+    this->bitSet = bitSet;
+    bool structureOK(true);
+    PVFieldPtr pvField = pvStructure->getSubField("timeStamp");
+    if(pvField==NULL) structureOK = false;
+    pvField = pvStructure->getSubField("value");
+    if(pvField==NULL) {
+         structureOK = false;
+    } else {
+        FieldConstPtr field = pvField->getField();
+        if(field->getType()!=scalarArray) {
+            structureOK = false; 
+        } else {
+            ScalarArrayConstPtr scalarArray = dynamic_pointer_cast<const ScalarArray>(field);
+            if(scalarArray->getElementType()!=pvLong) structureOK = false;
+        }
+    }
+    if(!structureOK) {
+        String mess("channelGetConnect: illegal structure");
+        message(mess,errorMessage);
+        this->status = Status(Status::STATUSTYPE_ERROR,mess);
+    }
+    event.signal();
+}
+
+void LongArrayChannelGet::run()
+{
+    while(true) {
+        event.wait();
+        if(isDestroyed) {
+            runReturned = true;
+            return;
+        }
+        TimeStamp timeStamp;
+        TimeStamp timeStampLast;
+        timeStampLast.getCurrent();
+        int numChannelGet = 0;
+        int numChannelCreate = 0;
+        size_t nElements = 0;
+        while(true) {
+            channelGet->get(false);
+            event.wait();
+            if(isDestroyed) {
+                runReturned = true;
+                return;
+            }
+            size_t latestSize = checkResult();
+            nElements += latestSize;
+            timeStamp.getCurrent();
+            double diff = TimeStamp::diff(timeStamp,timeStampLast);
+            if(diff>=1.0) {
+                ostringstream out;
+                out << "get";
+                double elementsPerSec = nElements;
+                elementsPerSec /= diff;
+                if(elementsPerSec>10.0e9) {
+                     elementsPerSec /= 1e9;
+                     out << " gigaElements/sec " << elementsPerSec;
+                } else if(elementsPerSec>10.0e6) {
+                     elementsPerSec /= 1e6;
+                     out << " megaElements/sec " << elementsPerSec;
+                } else if(elementsPerSec>10.0e3) {
+                     elementsPerSec /= 1e3;
+                     out << " kiloElements/sec " << elementsPerSec;
+                } else  {
+                     out << " Elements/sec " << elementsPerSec;
+                }
+                cout << out.str() << endl;
+                timeStampLast = timeStamp;
+                nElements = 0;
+            }
+            if(delayTime>0.0) epicsThreadSleep(delayTime);
+            if(isDestroyed) {
+                runReturned = true;
+                return;
+            }
+            ++numChannelCreate;
+            bool createGet = false;
+            if(iterBetweenCreateChannel!=0) {
+                if(numChannelCreate>=iterBetweenCreateChannel) {
+                    channel->destroy();
+                    ChannelProvider::shared_pointer channelProvider =
+                         getChannelAccess()->getProvider(providerName);
+                    channel = channelProvider->createChannel(
+                         channelName,getPtrSelf(),0);
+                    event.wait();
+                    channelProvider.reset();
+                    if(!status.isOK()) {
+                         message(status.getMessage(),errorMessage);
+                         return;
+                    }
+                    cout<< "createChannel success" << endl;
+                    createGet = true;
+                    numChannelCreate = 0;
+                    numChannelGet = 0;
+                }
+            }
+            ++numChannelGet;
+            if(iterBetweenCreateChannelGet!=0) {
+                if(numChannelGet>=iterBetweenCreateChannelGet) createGet = true;
+            }
+            if(createGet) {
+                 numChannelGet = 0;
+                 channelGet->destroy();
+                 CreateRequest::shared_pointer createRequest = CreateRequest::create();
+                 PVStructurePtr pvRequest = createRequest->createRequest(request);
+                 if(pvRequest==NULL) {
+                     cout << "request logic error " << createRequest->getMessage() << endl;
+                     return ;
+                 }
+                 channelGet = channel->createChannelGet(getPtrSelf(),pvRequest);
+                 event.wait();
+                 if(!status.isOK()) {
+                      message(status.getMessage(),errorMessage);
+                      return;
+                 }
+                 cout<< "createChannelGet success" << endl;
+            }
+        }
+    }
+}
+
+void LongArrayChannelGet::getDone(Status const & status)
+{
+    event.signal();
+}
+
+size_t LongArrayChannelGet::checkResult()
+{
+    PVLongArrayPtr pvValue;
+    if(!status.isOK()) {
+         message(status.getMessage(),errorMessage);
+         return 0;
+    }
+    pvValue = dynamic_pointer_cast<PVLongArray>(pvStructure->getSubField("value"));
+    if(!bitSet->get(pvValue->getFieldOffset())) {
+        return 0;
+    }
+    bitSet->clear();
+    shared_vector<const int64> data = pvValue->view();
+    if(data.size()>0) {
+        int64 first = data[0];
+        int64 last = data[data.size()-1];
+        if(first!=last) {
+           cout << "error first=" << first << " last=" << last << endl;
+        }
+    }
+    return data.size();
+}
+
+
+LongArrayGetPtr LongArrayGet::create(
+    String const &providerName,
+    String const & channelName,
+    int iterBetweenCreateChannel,
+    int iterBetweenCreateChannelGet,
+    double delayTime)
+{
+    LongArrayGetPtr longArrayGet(
+        new LongArrayGet(
+            providerName,
+            channelName,
+            iterBetweenCreateChannel,
+            iterBetweenCreateChannelGet,
+            delayTime));
+    if(!longArrayGet->init()) longArrayGet.reset();
+    return longArrayGet;
+}
+
+LongArrayGet::LongArrayGet(
+    String const &providerName,
+    String const & channelName,
+    int iterBetweenCreateChannel,
+    int iterBetweenCreateChannelGet,
+    double delayTime)
+: providerName(providerName),
+  channelName(channelName),
+  iterBetweenCreateChannel(iterBetweenCreateChannel),
+  iterBetweenCreateChannelGet(iterBetweenCreateChannelGet),
+  delayTime(delayTime)
+{}
+
+
+LongArrayGet::~LongArrayGet() {}
+
+bool LongArrayGet::init()
+{
+    longArrayChannelGet = LongArrayChannelGetPtr(new LongArrayChannelGet(
+        providerName,
+        channelName,
+        iterBetweenCreateChannel,
+        iterBetweenCreateChannelGet,
+        delayTime));
+    return  longArrayChannelGet->init();
+}
+
+void LongArrayGet::destroy()
+{
+    longArrayChannelGet->destroy();
+    longArrayChannelGet.reset();
+}
+
+}}
+
+

example/src/arrayPerformance/longArrayGet.h

@@ -0,0 +1,68 @@
+/* longArrayGet.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 LONGARRAYGET_H
+#define LONGARRAYGET_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 LongArrayGet;
+typedef std::tr1::shared_ptr<LongArrayGet> LongArrayGetPtr;
+
+
+class LongArrayChannelGet;
+typedef std::tr1::shared_ptr<LongArrayChannelGet> LongArrayChannelGetPtr;
+
+class LongArrayGet :
+    public std::tr1::enable_shared_from_this<LongArrayGet>
+{
+public:
+    POINTER_DEFINITIONS(LongArrayGet);
+    static LongArrayGetPtr create(
+        epics::pvData::String const & providerName,
+        epics::pvData::String const & channelName,
+        int iterBetweenCreateChannel = 0,
+        int iterBetweenCreateChannelGet = 0,
+        double delayTime = 0.0);
+    ~LongArrayGet();
+    void destroy();
+private:
+    LongArrayGetPtr getPtrSelf()
+    {
+        return shared_from_this();
+    }
+    LongArrayGet(
+        epics::pvData::String const & providerName,
+        epics::pvData::String const & channelName,
+        int iterBetweenCreateChannel = 0,
+        int iterBetweenCreateChannelGet = 0,
+        double delayTime = 0.0);
+    bool init();
+
+    epics::pvData::String providerName;
+    epics::pvData::String channelName;
+    int iterBetweenCreateChannel;
+    int iterBetweenCreateChannelGet;
+    double delayTime;
+    LongArrayChannelGetPtr longArrayChannelGet;
+};
+
+
+}}
+
+#endif  /* LONGARRAYGET_H */

example/src/arrayPerformance/longArrayMonitor.cpp

@@ -21,6 +21,7 @@ using std::tr1::static_pointer_cast;
 using std::tr1::dynamic_pointer_cast;
 using std::cout;
 using std::endl;
+using std::ostringstream;
 
 static String requesterName("longArrayMonitor");
 
@@ -86,7 +87,6 @@ public:
     virtual void monitorEvent(MonitorPtr const & monitor);
     virtual void unlisten(MonitorPtr const & monitor);
 private:
-    void handleMonitor();
     LongArrayMonitorPtr longArrayMonitor;
     double waitTime;
     bool isDestroyed;
@@ -160,6 +160,8 @@ void LAMMonitorRequester::run()
     TimeStamp timeStamp;
     TimeStamp timeStampLast;
     timeStampLast.getCurrent();
+    size_t nElements = 0;
+    int nSinceLastReport = 0;
     while(true) {
         event.wait();
         if(isDestroyed) {
@@ -181,25 +183,45 @@ void LAMMonitorRequester::run()
             pvValue = dynamic_pointer_cast<PVLongArray>(pvStructure->getSubField("value"));
             shared_vector<const int64> data = pvValue->view();
             if(data.size()>0) {
+                nElements += data.size();
                 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];
+                if(first!=last) {
+                    cout << "error first=" << first << " last=" << last << endl;
+                }
                 double diff = TimeStamp::diff(timeStamp,timeStampLast);
-                double elementsPerSecond = data.size();
-                elementsPerSecond = 1e-6*elementsPerSecond/diff;
-                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;
-                timeStampLast = timeStamp;
+                if(diff>=1.0) {
+                    ostringstream out;
+                    out << " monitors/sec " << nSinceLastReport << " ";
+                    out << "first " << first << " last " << last ;
+                    BitSetPtr changed = monitorElement->changedBitSet;
+                    BitSetPtr overrun = monitorElement->overrunBitSet;
+                    String buffer;
+                    changed->toString(&buffer);
+                    out << " changed " << buffer;
+                    buffer.clear();
+                    overrun->toString(&buffer);
+                    out << " overrun " << buffer;
+                    double elementsPerSec = nElements;
+                    elementsPerSec /= diff;
+                    if(elementsPerSec>10.0e9) {
+                         elementsPerSec /= 1e9;
+                         out << " gigaElements/sec " << elementsPerSec;
+                    } else if(elementsPerSec>10.0e6) {
+                         elementsPerSec /= 1e6;
+                         out << " megaElements/sec " << elementsPerSec;
+                    } else if(elementsPerSec>10.0e3) {
+                         elementsPerSec /= 1e3;
+                         out << " kiloElements/sec " << elementsPerSec;
+                    } else  {
+                         out << " Elements/sec " << elementsPerSec;
+                    }
+                    cout << out.str() << endl;
+                    timeStampLast = timeStamp;
+                    nSinceLastReport = 0;
+                    nElements = 0;
+                }
+                ++nSinceLastReport;
             } else {
                 cout << "size = 0" << endl;
             }

example/src/arrayPerformance/longArrayPut.cpp

@@ -0,0 +1,374 @@
+/* longArrayPut.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/longArrayPut.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;
+using std::ostringstream;
+
+static String requesterName("longArrayPut");
+static String request("value");
+static epics::pvData::Mutex printMutex;
+
+class LongArrayChannelPut :
+    virtual public ChannelRequester,
+    virtual public ChannelPutRequester,
+    public std::tr1::enable_shared_from_this<LongArrayChannelPut>,
+    public epicsThreadRunable
+{
+public:
+    LongArrayChannelPut(
+        String providerName,
+        String channelName,
+        size_t arraySize,
+        int iterBetweenCreateChannel,
+        int iterBetweenCreateChannelPut,
+        double delayTime)
+    : providerName(providerName),
+      channelName(channelName),
+      arraySize(arraySize),
+      iterBetweenCreateChannel(iterBetweenCreateChannel),
+      iterBetweenCreateChannelPut(iterBetweenCreateChannelPut),
+      delayTime(delayTime),
+      isDestroyed(false),
+      runReturned(false),
+      threadName("longArrayPut")
+    {}
+    virtual ~LongArrayChannelPut(){}
+    bool init();
+    virtual void destroy();
+    virtual void run();
+    virtual String getRequesterName() { return requesterName;}
+    virtual void message(String const & message, MessageType messageType)
+       {
+           Lock guard(printMutex);
+           cout << requesterName << " message " << message << endl;
+       }
+    virtual void channelCreated(
+        const Status& status,
+        Channel::shared_pointer const & channel);
+    virtual void channelStateChange(
+        Channel::shared_pointer const & channel,
+        Channel::ConnectionState connectionState);
+    virtual void channelPutConnect(
+        Status const & status,
+        ChannelPut::shared_pointer const & channelPut,
+        PVStructurePtr const &pvStructure,
+        BitSetPtr const &bitSet);
+    virtual void putDone(Status const & status);
+    virtual void getDone(Status const & status){}
+private:
+    LongArrayChannelPutPtr getPtrSelf()
+    {
+        return shared_from_this();
+    }
+    String providerName;
+    String channelName;
+    size_t arraySize;
+    int iterBetweenCreateChannel;
+    int iterBetweenCreateChannelPut;
+    double delayTime;
+    bool isDestroyed;
+    bool runReturned;
+    epics::pvData::String threadName;
+    Status status;
+    Event event;
+    Mutex mutex;
+    std::auto_ptr<epicsThread> thread;
+    Channel::shared_pointer channel;
+    ChannelPut::shared_pointer channelPut;
+    PVStructurePtr pvStructure;
+    PVLongArrayPtr pvLongArray;
+    BitSetPtr bitSet;
+};
+
+bool LongArrayChannelPut::init()
+{
+    ChannelProvider::shared_pointer channelProvider = getChannelAccess()->getProvider(providerName);
+    if(channelProvider==NULL) {
+        cout << "provider " << providerName << " not found" << endl;
+        return false;
+    }
+    channel = channelProvider->createChannel(channelName,getPtrSelf(),0);
+    event.wait();
+    if(!status.isOK()) return false;
+    CreateRequest::shared_pointer createRequest = CreateRequest::create();
+    PVStructurePtr pvRequest = createRequest->createRequest(request);
+    if(pvRequest==NULL) {
+        cout << "request logic error " << createRequest->getMessage() << endl;
+        return false;
+    }
+    channelPut = channel->createChannelPut(getPtrSelf(),pvRequest);
+    event.wait();
+    if(!status.isOK()) return false;
+     thread = std::auto_ptr<epicsThread>(new epicsThread(
+        *this,
+        threadName.c_str(),
+        epicsThreadGetStackSize(epicsThreadStackSmall),
+        epicsThreadPriorityLow));
+     thread->start();
+     event.signal();
+     return true;
+}
+
+void LongArrayChannelPut::destroy()
+{
+    if(isDestroyed) return;
+    isDestroyed = true;
+    event.signal();
+    while(true) {
+        if(runReturned) break;
+        epicsThreadSleep(.01);
+    }
+    thread->exitWait();
+    channel->destroy();
+    channelPut.reset();
+    channel.reset();
+}
+
+void LongArrayChannelPut::channelCreated(
+    const Status& status,
+    Channel::shared_pointer const & channel)
+{
+    if(!status.isOK()) message(status.getMessage(),errorMessage);
+    this->status = status;
+    this->channel = channel;
+    event.signal();
+}
+
+void LongArrayChannelPut::channelStateChange(
+    Channel::shared_pointer const & channel,
+    Channel::ConnectionState connectionState)
+{
+   MessageType messageType =
+       (connectionState==Channel::CONNECTED ? infoMessage : errorMessage);
+   message("channelStateChange",messageType);
+}
+
+
+void LongArrayChannelPut::channelPutConnect(
+        Status const & status,
+        ChannelPut::shared_pointer const & channelPut,
+        PVStructurePtr const &pvStructure,
+        BitSetPtr const &bitSet)
+{
+    this->status = status;
+    if(!status.isOK())  {
+        message(status.getMessage(),errorMessage);
+        event.signal();
+        return;
+    }
+    this->channelPut = channelPut;
+    this->pvStructure = pvStructure;
+    this->bitSet = bitSet;
+    bool structureOK(true);
+    PVFieldPtr pvField = pvStructure->getSubField("value");
+    if(pvField==NULL) {
+         structureOK = false;
+    } else {
+        FieldConstPtr field = pvField->getField();
+        if(field->getType()!=scalarArray) {
+            structureOK = false; 
+        } else {
+            ScalarArrayConstPtr scalarArray = dynamic_pointer_cast<const ScalarArray>(field);
+            if(scalarArray->getElementType()!=pvLong) structureOK = false;
+        }
+    }
+    if(!structureOK) {
+        String mess("channelPutConnect: illegal structure");
+        message(mess,errorMessage);
+        this->status = Status(Status::STATUSTYPE_ERROR,mess);
+    }
+    pvLongArray = static_pointer_cast<PVLongArray>(pvField);
+    event.signal();
+}
+
+void LongArrayChannelPut::run()
+{
+    while(true) {
+        event.wait();
+        if(isDestroyed) {
+            runReturned = true;
+            return;
+        }
+        TimeStamp timeStamp;
+        TimeStamp timeStampLast;
+        timeStampLast.getCurrent();
+        int numChannelPut = 0;
+        int numChannelCreate = 0;
+        size_t nElements = 0;
+        while(true) {
+            nElements += sizeof(int64) * arraySize;
+            shared_vector<int64> xxx(arraySize,numChannelPut);
+            shared_vector<const int64> data(freeze(xxx));
+            pvLongArray->replace(data);
+            bitSet->set(pvLongArray->getFieldOffset());
+            channelPut->put(false);
+            event.wait();
+            if(isDestroyed) {
+                runReturned = true;
+                return;
+            }
+            if(delayTime>0.0) epicsThreadSleep(delayTime);
+            if(isDestroyed) {
+                runReturned = true;
+                return;
+            }
+            timeStamp.getCurrent();
+            double diff = TimeStamp::diff(timeStamp,timeStampLast);
+            if(diff>=1.0) {
+                ostringstream out;
+                out << "put numChannelPut " << numChannelPut;
+                out << " time " << diff ;
+                double elementsPerSec = nElements;
+                elementsPerSec /= diff;
+                if(elementsPerSec>10.0e9) {
+                     elementsPerSec /= 1e9;
+                     out << " gigaElements/sec " << elementsPerSec;
+                } else if(elementsPerSec>10.0e6) {
+                     elementsPerSec /= 1e6;
+                     out << " megaElements/sec " << elementsPerSec;
+                } else if(elementsPerSec>10.0e3) {
+                     elementsPerSec /= 1e3;
+                     out << " kiloElements/sec " << elementsPerSec;
+                } else  {
+                     out << " Elements/sec " << elementsPerSec;
+                }
+                cout << out.str() << endl;
+                timeStampLast = timeStamp;
+                nElements = 0;
+            }
+            ++numChannelCreate;
+            bool createPut = false;
+            if(iterBetweenCreateChannel!=0) {
+                if(numChannelCreate>=iterBetweenCreateChannel) {
+                    channel->destroy();
+                    ChannelProvider::shared_pointer channelProvider =
+                         getChannelAccess()->getProvider(providerName);
+                    channel = channelProvider->createChannel(channelName,getPtrSelf(),0);
+                    event.wait();
+                    if(isDestroyed) {
+                        runReturned = true;
+                        return;
+                    }
+                    if(!status.isOK()) {
+                         message(status.getMessage(),errorMessage);
+                         return;
+                    }
+                    cout<< "createChannel success" << endl;
+                    createPut = true;
+                    numChannelCreate = 0;
+                    numChannelPut = 0;
+                }
+            }
+            ++numChannelPut;
+            if(iterBetweenCreateChannelPut!=0) {
+                if(numChannelPut>=iterBetweenCreateChannelPut) createPut = true;
+            }
+            if(createPut) {
+                 numChannelPut = 0;
+                 channelPut->destroy();
+                 CreateRequest::shared_pointer createRequest = CreateRequest::create();
+                 PVStructurePtr pvRequest = createRequest->createRequest(request);
+                 if(pvRequest==NULL) {
+                     cout << "request logic error " << createRequest->getMessage() << endl;
+                     return ;
+                 }
+                 channelPut = channel->createChannelPut(getPtrSelf(),pvRequest);
+                 event.wait();
+                 if(isDestroyed) {
+                     runReturned = true;
+                     return;
+                 }
+                 if(!status.isOK()) {
+                      message(status.getMessage(),errorMessage);
+                      return;
+                 }
+                 cout<< "createChannelPut success" << endl;
+            }
+        }
+    }
+}
+
+void LongArrayChannelPut::putDone(Status const & status)
+{
+    event.signal();
+}
+
+
+LongArrayPutPtr LongArrayPut::create(
+    String const &providerName,
+    String const & channelName,
+    size_t arraySize,
+    int iterBetweenCreateChannel,
+    int iterBetweenCreateChannelPut,
+    double delayTime)
+{
+    LongArrayPutPtr longArrayPut(
+        new LongArrayPut(
+            providerName,
+            channelName,
+            arraySize,
+            iterBetweenCreateChannel,
+            iterBetweenCreateChannelPut,
+            delayTime));
+    if(!longArrayPut->init()) longArrayPut.reset();
+    return longArrayPut;
+}
+
+LongArrayPut::LongArrayPut(
+    String const &providerName,
+    String const & channelName,
+    size_t arraySize,
+    int iterBetweenCreateChannel,
+    int iterBetweenCreateChannelPut,
+    double delayTime)
+: providerName(providerName),
+  channelName(channelName),
+  arraySize(arraySize),
+  iterBetweenCreateChannel(iterBetweenCreateChannel),
+  iterBetweenCreateChannelPut(iterBetweenCreateChannelPut),
+  delayTime(delayTime)
+{}
+
+
+LongArrayPut::~LongArrayPut() {}
+
+bool LongArrayPut::init()
+{
+    longArrayChannelPut = LongArrayChannelPutPtr(new LongArrayChannelPut(
+        providerName,
+        channelName,
+        arraySize,
+        iterBetweenCreateChannel,
+        iterBetweenCreateChannelPut,
+        delayTime));
+    return  longArrayChannelPut->init();
+}
+
+void LongArrayPut::destroy()
+{
+    longArrayChannelPut->destroy();
+    longArrayChannelPut.reset();
+}
+
+}}
+
+

example/src/arrayPerformance/longArrayPut.h

@@ -0,0 +1,71 @@
+/* longArrayPut.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 LONGARRAYPUT_H
+#define LONGARRAYPUT_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 LongArrayPut;
+typedef std::tr1::shared_ptr<LongArrayPut> LongArrayPutPtr;
+
+
+class LongArrayChannelPut;
+typedef std::tr1::shared_ptr<LongArrayChannelPut> LongArrayChannelPutPtr;
+
+class LongArrayPut :
+    public std::tr1::enable_shared_from_this<LongArrayPut>
+{
+public:
+    POINTER_DEFINITIONS(LongArrayPut);
+    static LongArrayPutPtr create(
+        epics::pvData::String const & providerName,
+        epics::pvData::String const & channelName,
+        size_t arraySize = 100,
+        int iterBetweenCreateChannel = 0,
+        int iterBetweenCreateChannelPut = 0,
+        double delayTime = 0.0);
+    ~LongArrayPut();
+    void destroy();
+private:
+    LongArrayPutPtr getPtrSelf()
+    {
+        return shared_from_this();
+    }
+    LongArrayPut(
+        epics::pvData::String const & providerName,
+        epics::pvData::String const & channelName,
+        size_t arraySize,
+        int iterBetweenCreateChannel,
+        int iterBetweenCreateChannelPut,
+        double delayTime);
+    bool init();
+
+    epics::pvData::String providerName;
+    epics::pvData::String channelName;
+    size_t arraySize;
+    int iterBetweenCreateChannel;
+    int iterBetweenCreateChannelPut;
+    double delayTime;
+    LongArrayChannelPutPtr longArrayChannelPut;
+};
+
+
+}}
+
+#endif  /* LONGARRAYPUT_H */