epics/pvData
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

more shared_pointer everywhere

Browse Source
This commit is contained in:
Marty Kraimer
2012-07-17 09:23:53 -04:00
parent 32790674d6
commit 5dcd864c58
25 changed files with 399 additions and 1507 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
testApp/misc/Makefile
View File

@@ -42,10 +42,6 @@ PROD_HOST += testMessageQueue
testMessageQueue_SRCS += testMessageQueue.cpp
testMessageQueue_LIBS += pvData Com
PROD_HOST += testLinkedList
testLinkedList_SRCS += testLinkedList.cpp
testLinkedList_LIBS += pvData Com
include $(TOP)/configure/RULES
#----------------------------------------
# ADD RULES AFTER THIS LINE

3
testApp/misc/testBitSet.cpp
View File

@@ -12,7 +12,6 @@
#include <string.h>
#include <stdio.h>
#include <pv/bitSet.h>
#include <pv/CDRMonitor.h>
#include <epicsAssert.h>
#include <epicsExit.h>
@@ -150,8 +149,6 @@ int main(int argc,char *argv[])
}
testGetSetClearFlip(fd);
testOperators(fd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd);
return(0);
}

450
testApp/misc/testLinkedList.cpp
View File

@@ -1,450 +0,0 @@
/**
* 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.
*/
/*
* testLinkedList.cpp
*
* Created on: 2010.11
* Author: Marty Kraimer
*/
#include <cstddef>
#include <cstdlib>
#include <cstddef>
#include <string>
#include <cstdio>
#include <list>
#include <epicsAssert.h>
#include <epicsExit.h>
#include <pv/lock.h>
#include <pv/timeStamp.h>
#include <pv/linkedList.h>
#include <pv/CDRMonitor.h>
using namespace epics::pvData;
static const int numNodes = 5;
class Basic;
typedef LinkedListNode<Basic> BasicListNode;
typedef LinkedList<Basic> BasicList;
class Basic {
public:
Basic(int i): index(i),node(*this) {}
~Basic() { }
int index;
BasicListNode node;
};
static void testBasic(FILE * fd ) {
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
basicList.addTail(basics[i]->node);
assert(basicList.getLength()==i+1);
}
BasicListNode *basicNode = basicList.getHead();
fprintf(fd,"basic addTail");
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.getNext(*basicNode);
}
assert(basicList.isEmpty()==false);
basicNode = basicList.getTail();
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
assert(basicNode->isOnList());
basicNode = basicList.getPrev(*basicNode);
}
fprintf(fd,"\n");
for(int i=0; i<numNodes; i++) {
basicNode = basicList.getHead();
assert(basicNode!=0);
Basic &basic = basicNode->getObject();
assert(basic.index==i);
assert(basics[i]->node.isOnList()==true);
basicList.remove(basics[i]->node);
assert(basics[i]->node.isOnList()==false);
int length = basicList.getLength();
assert(length==(numNodes-i-1));
}
assert(basicList.isEmpty());
for(int i=numNodes-1; i>=0; i--) {
basicList.addHead(basics[i]->node);
assert(basicList.getLength()==numNodes-i);
}
basicNode = basicList.getHead();
fprintf(fd,"basic addHead");
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.getNext(*basicNode);
}
fprintf(fd,"\n");
for(int i=0; i<numNodes; i++) {
basicNode = basicList.getHead();
assert(basicNode!=0);
Basic &basic = basicNode->getObject();
assert(basic.index==i);
basicList.removeHead();
assert(basic.node.isOnList()==false);
int length = basicList.getLength();
assert(length==(numNodes-i-1));
}
assert(basicList.isEmpty());
basicList.addTail(basics[0]->node);
basicNode = basicList.getTail();
assert(basicNode->getObject().index==0);
for(int i=1;i<numNodes;i++) {
basicList.insertAfter(*basicNode,basics[i]->node);
basicNode = basicList.getTail();
assert(basicList.getLength()==i+1);
}
fprintf(fd,"basic addTail insertAfter");
basicNode = basicList.getHead();
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.getNext(*basicNode);
}
fprintf(fd,"\n");
for(int i=numNodes-1; i>=0; i--) {
Basic &basic = basicList.getTail()->getObject();
assert(basic.index==i);
basicList.removeTail();
assert(basic.node.isOnList()==false);
int length = basicList.getLength();
assert(length==i);
}
assert(basicList.isEmpty());
basicList.addHead(basics[numNodes-1]->node);
basicNode = basicList.getHead();
assert(basicNode->getObject().index==4);
for(int i=numNodes-2; i>=0; i--) {
basicList.insertBefore(*basicNode,basics[i]->node);
basicNode = basicList.getHead();
assert(basicList.getLength()==numNodes-i);
}
fprintf(fd,"basic addTail insertBefore");
basicNode = basicList.getHead();
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.getNext(*basicNode);
}
fprintf(fd,"\n");
for(int i=numNodes-1; i>=0; i--) {
Basic &basic = basicList.getTail()->getObject();
assert(basic.index==i);
basicList.remove(basic.node);
assert(basic.node.isOnList()==false);
int length = basicList.getLength();
assert(length==i);
}
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testQueue(FILE * fd ) {
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(fd,"\nQueue test\n");
for(int i=0;i<numNodes;i++) {
basicList.addTail(basics[i]->node);
assert(basicList.getLength()==i+1);
}
BasicListNode *basicNode = basicList.removeHead();
while(basicNode!=0) basicNode = basicList.removeHead();
for(int i=0;i<numNodes;i++) basicList.addTail(basics[i]->node);
basicNode = basicList.removeHead();
fprintf(fd,"queue");
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.removeHead();
}
fprintf(fd,"\n");
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testStack(FILE * fd ) {
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(fd,"\nStack test\n");
for(int i=0;i<numNodes;i++) {
basicList.addHead(basics[i]->node);
assert(basicList.getLength()==i+1);
}
BasicListNode *basicNode = basicList.removeHead();
while(basicNode!=0) basicNode = basicList.removeHead();
for(int i=0;i<numNodes;i++) basicList.addHead(basics[i]->node);
basicNode = basicList.removeHead();
fprintf(fd,"stack");
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.removeHead();
}
fprintf(fd,"\n");
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testList(FILE * fd ) {
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(fd,"\ntestList\n");
for(int i=0;i<numNodes;i++) basicList.addTail(basics[i]->node);
fprintf(fd,"list");
BasicListNode *basicNode = basicList.removeHead();
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.removeHead();
}
fprintf(fd,"\n");
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testRandomInsertRemove(FILE * fd ) {
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(fd,"\nRandom insert/remove test\n");
basicList.addHead(basics[4]->node);
basicList.insertAfter(basics[4]->node,basics[3]->node);
basicList.insertAfter(basics[3]->node,basics[2]->node);
basicList.addTail(basics[1]->node);
basicList.addTail(basics[0]->node);
BasicListNode *basicNode = basicList.removeHead();
fprintf(fd,"stack");
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.removeHead();
}
fprintf(fd,"\n");
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testOrderedQueue(FILE * fd ) {
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
BasicListNode *basicNode = 0;
fprintf(fd,"\nOrdered Queue test\n");
basicList.addHead(basics[2]->node);
for(int i=0;i<numNodes;i++) {
if(basics[i]->node.isOnList()) continue;
basicNode = basicList.getHead();
while(basicNode!=0) {
if(basicNode->getObject().index>=basics[i]->index) {
basicList.insertBefore(*basicNode,basics[i]->node);
break;
}
basicNode = basicList.getNext(*basicNode);
}
if(basics[i]->node.isOnList()) continue;
basicList.addTail(basics[i]->node);
}
fprintf(fd,"list");
basicNode = basicList.removeHead();
while(basicNode!=0) {
fprintf(fd," %d",basicNode->getObject().index);
basicNode = basicList.removeHead();
}
fprintf(fd,"\n");
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testTime(FILE *auxFd) {
TimeStamp startTime;
TimeStamp endTime;
const int numNodes = 1000;
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(auxFd,"\nTime test\n");
int ntimes = 1000;
startTime.getCurrent();
for(int i=0; i<ntimes; i++) {
for(int j=0;j<numNodes;j++) basicList.addTail(basics[j]->node);
BasicListNode *basicNode = basicList.removeHead();
while(basicNode!=0) basicNode = basicList.removeHead();
}
endTime.getCurrent();
double diff = TimeStamp::diff(endTime,startTime);
diff *= 1000.0;
fprintf(auxFd,"diff %f milliSeconds\n",diff);
diff = diff/1000.0; // convert from milliseconds to seconds
diff = diff/ntimes; // seconds per outer loop
diff = diff*1e6; // converty to microseconds
fprintf(auxFd,"time per iteration %f microseconds\n",diff);
diff = diff/(numNodes*2); // convert to per addTail/removeHead
fprintf(auxFd,"time per addTail/removeHead %f microseconds\n",diff);
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testTimeLocked(FILE *auxFd) {
TimeStamp startTime;
TimeStamp endTime;
Mutex mutex;
const int numNodes = 1000;
LinkedList<Basic> basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(auxFd,"\nTime test locked\n");
int ntimes = 1000;
startTime.getCurrent();
for(int i=0; i<ntimes; i++) {
for(int j=0;j<numNodes;j++) {
Lock xx(mutex);
basicList.addTail(basics[j]->node);
}
BasicListNode *basicNode = 0;
{
Lock xx(mutex);
basicNode = basicList.removeHead();
}
while(basicNode!=0) {
Lock xx(mutex);
basicNode = basicList.removeHead();
}
}
endTime.getCurrent();
double diff = TimeStamp::diff(endTime,startTime);
diff *= 1000.0;
fprintf(auxFd,"diff %f milliSeconds\n",diff);
diff = diff/1000.0; // convert from milliseconds to seconds
diff = diff/ntimes; // seconds per outer loop
diff = diff*1e6; // converty to microseconds
fprintf(auxFd,"time per iteration %f microseconds\n",diff);
diff = diff/(numNodes*2); // convert to per addTail/removeHead
fprintf(auxFd,"time per addTail/removeHead %f microseconds\n",diff);
assert(basicList.isEmpty());
for(int i=0; i<numNodes; i++) delete basics[i];
}
typedef std::list<Basic *> stdList;
static void testStdListTime(FILE *auxFd) {
TimeStamp startTime;
TimeStamp endTime;
const int numNodes = 1000;
stdList basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(auxFd,"\nTime std::list test\n");
int ntimes = 1000;
startTime.getCurrent();
for(int i=0; i<ntimes; i++) {
for(int j=0;j<numNodes;j++) basicList.push_back(basics[j]);
while(basicList.size()>0) {
basicList.begin();
basicList.pop_front();
}
}
endTime.getCurrent();
double diff = TimeStamp::diff(endTime,startTime);
diff *= 1000.0;
fprintf(auxFd,"diff %f milliSeconds\n",diff);
diff = diff/1000.0; // convert from milliseconds to seconds
diff = diff/ntimes; // seconds per outer loop
diff = diff*1e6; // converty to microseconds
fprintf(auxFd,"time per iteration %f microseconds\n",diff);
diff = diff/(numNodes*2); // convert to per addTail/removeHead
fprintf(auxFd,"time per addTail/removeHead %f microseconds\n",diff);
for(int i=0; i<numNodes; i++) delete basics[i];
}
static void testStdListTimeLocked(FILE *auxFd) {
TimeStamp startTime;
TimeStamp endTime;
const int numNodes = 1000;
Mutex mutex;
stdList basicList;
Basic *basics[numNodes];
for(int i=0; i<numNodes; i++) {
basics[i] = new Basic(i);
}
fprintf(auxFd,"\nTime std::list test locked\n");
int ntimes = 1000;
startTime.getCurrent();
for(int i=0; i<ntimes; i++) {
for(int j=0;j<numNodes;j++) {
Lock xx(mutex);
basicList.push_back(basics[j]);
}
while(basicList.size()>0) {
Lock xx(mutex);
basicList.begin();
basicList.pop_front();
}
}
endTime.getCurrent();
double diff = TimeStamp::diff(endTime,startTime);
diff *= 1000.0;
fprintf(auxFd,"diff %f milliSeconds\n",diff);
diff = diff/1000.0; // convert from milliseconds to seconds
diff = diff/ntimes; // seconds per outer loop
diff = diff*1e6; // converty to microseconds
fprintf(auxFd,"time per iteration %f microseconds\n",diff);
diff = diff/(numNodes*2); // convert to per addTail/removeHead
fprintf(auxFd,"time per addTail/removeHead %f microseconds\n",diff);
for(int i=0; i<numNodes; i++) delete basics[i];
}
int main(int argc, char *argv[]) {
char *fileName = 0;
if(argc>1) fileName = argv[1];
FILE * fd = stdout;
if(fileName!=0 && fileName[0]!=0) {
fd = fopen(fileName,"w+");
}
char *auxFileName = 0;
if(argc>2) auxFileName = argv[2];
FILE *auxFd = stdout;
if(auxFileName!=0 && auxFileName[0]!=0) {
auxFd = fopen(auxFileName,"w+");
}
testBasic(fd);
testQueue(fd);
testStack(fd);
testList(fd);
testRandomInsertRemove(fd);
testOrderedQueue(fd);
testTime(auxFd);
testTimeLocked(auxFd);
testStdListTime(auxFd);
testStdListTimeLocked(auxFd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd);
return (0);
}

3
testApp/misc/testMessageQueue.cpp
View File

@@ -23,7 +23,6 @@
#include <pv/timeStamp.h>
#include <pv/requester.h>
#include <pv/messageQueue.h>
#include <pv/CDRMonitor.h>
#include <pv/event.h>
#include <pv/thread.h>
#include <pv/executor.h>
@@ -89,8 +88,6 @@ int main(int argc, char *argv[]) {
auxfd = fopen(auxFileName,"w+");
}
testBasic(fd,auxfd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd);
return (0);
}

3
testApp/misc/testSerialization.cpp
View File

@@ -20,7 +20,6 @@
#include <pv/serialize.h>
#include <pv/noDefaultMethods.h>
#include <pv/byteBuffer.h>
#include <pv/CDRMonitor.h>
#include <pv/convert.h>
#include <pv/standardField.h>
@@ -661,8 +660,6 @@ int main(int argc, char *argv[]) {
delete flusher;
epicsExitCallAtExits();
(*out)<<"Done.\n"<<CDRMonitor::get();
return 0;
}

83
testApp/misc/testThread.cpp
View File

@@ -23,7 +23,6 @@
#include <pv/event.h>
#include <pv/thread.h>
#include <pv/executor.h>
#include <pv/CDRMonitor.h>
#include <pv/timeFunction.h>
using namespace epics::pvData;
@@ -39,7 +38,7 @@ public:
begin.signal();
bool waited=end.wait();
actuallyRan=true;
fprintf(out, "Action1 %s\n", waited?"true":"false");
fprintf(out, "Action %s\n", waited?"true":"false");
}
};
@@ -49,81 +48,89 @@ static void testThreadRun(FILE *fd) {
{
Thread tr("Action", lowPriority, &ax);
bool w=ax.begin.wait();
fprintf(fd, "main1 %s\n", w?"true":"false");
fprintf(fd, "main %s\n", w?"true":"false");
fprintf(fd, "Action is %s\n", ax.actuallyRan?"true":"false");
ax.end.signal();
}
fprintf(fd, "Action is %s\n", ax.actuallyRan?"true":"false");
}
class Basic : public Command {
class Basic :
public Command,
public std::tr1::enable_shared_from_this<Basic>
{
public:
Basic(Executor *executor);
POINTER_DEFINITIONS(Basic);
Basic(ExecutorPtr const &executor);
~Basic();
void run();
virtual void command();
private:
Executor *executor;
ExecutorNode *executorNode;
Event *wait;
Basic::shared_pointer getPtrSelf()
{
return shared_from_this();
}
ExecutorPtr executor;
Event wait;
};
Basic::Basic(Executor *executor)
: executor(executor),
executorNode(executor->createNode(this)),
wait(new Event())
typedef std::tr1::shared_ptr<Basic> BasicPtr;
Basic::Basic(ExecutorPtr const &executor)
: executor(executor)
{
}
Basic::~Basic() {
delete wait;
}
void Basic::run()
{
executor->execute(executorNode);
bool result = wait->wait();
executor->execute(getPtrSelf());
bool result = wait.wait();
if(result==false) printf("basic::run wait returned false\n");
}
void Basic::command()
{
wait->signal();
wait.signal();
}
static void testBasic(FILE *fd) {
Executor *executor = new Executor(String("basic"),middlePriority);
Basic *basic = new Basic(executor);
ExecutorPtr executor( new Executor(String("basic"),middlePriority));
BasicPtr basic( new Basic(executor));
basic->run();
delete basic;
String buf("");
delete executor;
}
class MyFunc : public TimeFunctionRequester {
public:
MyFunc(Basic *basic)
: basic(basic)
{}
virtual void function()
{
basic->run();
}
POINTER_DEFINITIONS(MyFunc);
MyFunc(BasicPtr const &basic);
virtual void function();
private:
Basic *basic;
BasicPtr basic;
};
MyFunc::MyFunc(BasicPtr const &basic)
: basic(basic)
{}
void MyFunc::function()
{
basic->run();
}
typedef std::tr1::shared_ptr<MyFunc> MyFuncPtr;
static void testThreadContext(FILE *fd,FILE *auxFd) {
Executor *executor = new Executor(String("basic"),middlePriority);
Basic *basic = new Basic(executor);
MyFunc myFunc(basic);
TimeFunction timeFunction(&myFunc);
double perCall = timeFunction.timeCall();
ExecutorPtr executor(new Executor(String("basic"),middlePriority));
BasicPtr basic(new Basic(executor));
MyFuncPtr myFunc(new MyFunc(basic));
TimeFunctionPtr timeFunction(new TimeFunction(myFunc));
double perCall = timeFunction->timeCall();
perCall *= 1e6;
fprintf(auxFd,"time per call %f microseconds\n",perCall);
delete basic;
delete executor;
}
int main(int argc, char *argv[]) {
@@ -142,7 +149,5 @@ int main(int argc, char *argv[]) {
testThreadRun(fd);
testBasic(fd);
testThreadContext(fd,auxFd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd);
return (0);
return 0;
}

153
testApp/misc/testTimer.cpp
View File

@@ -22,19 +22,26 @@
#include <pv/event.h>
#include <pv/timer.h>
#include <pv/thread.h>
#include <pv/CDRMonitor.h>
using namespace epics::pvData;
static TimeStamp currentTimeStamp;
static double oneDelay = 4.0;
static double twoDelay = 2.0;
static double threeDelay = 1.0;
static int ntimes = 3;
class MyCallback;
typedef std::tr1::shared_ptr<MyCallback> MyCallbackPtr;
class MyCallback : public TimerCallback {
public:
MyCallback(String name,FILE *fd,FILE *auxfd,Event *wait)
: name(name),fd(fd),auxfd(auxfd),wait(wait),
timerNode(*this),timeStamp(TimeStamp())
POINTER_DEFINITIONS(MyCallback);
MyCallback(String name,FILE *fd,FILE *auxfd,EventPtr const & wait)
: name(name),
fd(fd),
auxfd(auxfd),
wait(wait)
{
}
~MyCallback()
@@ -49,45 +56,115 @@ public:
{
fprintf(fd,"timerStopped %s\n",name.c_str());
}
TimerNode &getTimerNode() { return timerNode;}
TimeStamp &getTimeStamp() { return timeStamp;}
private:
String name;
FILE *fd;
FILE *auxfd;
Event *wait;
TimerNode timerNode;
EventPtr wait;
TimeStamp timeStamp;
};
static void testBasic(FILE *fd, FILE *auxfd)
{
printf("\n\ntestBasic oneDelay %lf twoDelay %lf threeDaley %lf\n",
oneDelay,twoDelay,threeDelay);
String one("one");
String two("two");
Event *eventOne = new Event();
Event *eventTwo = new Event();
Timer *timer = new Timer(String("timer"),middlePriority);
MyCallback *callbackOne = new MyCallback(
one,fd,auxfd,eventOne);
MyCallback *callbackTwo = new MyCallback(
two,fd,auxfd,eventTwo);
currentTimeStamp.getCurrent();
timer->scheduleAfterDelay(callbackOne->getTimerNode(),oneDelay);
timer->scheduleAfterDelay(callbackTwo->getTimerNode(),twoDelay);
eventOne->wait();
eventTwo->wait();
double diff;
diff = TimeStamp::diff(
callbackOne->getTimeStamp(),currentTimeStamp);
fprintf(auxfd,"one requested %f diff %f seconds\n",oneDelay,diff);
diff = TimeStamp::diff(
callbackTwo->getTimeStamp(),currentTimeStamp);
fprintf(auxfd,"two requested %f diff %f seconds\n",twoDelay,diff);
delete timer;
delete callbackTwo;
delete callbackOne;
delete eventTwo;
delete eventOne;
String three("three");
EventPtr eventOne(new Event());
EventPtr eventTwo(new Event());
EventPtr eventThree(new Event());
TimerPtr timer(new Timer(String("timer"),middlePriority));
MyCallbackPtr callbackOne(new MyCallback(one,fd,auxfd,eventOne));
MyCallbackPtr callbackTwo(new MyCallback(two,fd,auxfd,eventTwo));
MyCallbackPtr callbackThree(new MyCallback(three,fd,auxfd,eventThree));
for(int n=0; n<ntimes; n++) {
currentTimeStamp.getCurrent();
assert(!timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
assert(!timer->isScheduled(callbackThree));
timer->scheduleAfterDelay(callbackOne,oneDelay);
timer->scheduleAfterDelay(callbackTwo,twoDelay);
timer->scheduleAfterDelay(callbackThree,threeDelay);
if(oneDelay>.1) assert(timer->isScheduled(callbackOne));
if(twoDelay>.1) assert(timer->isScheduled(callbackTwo));
if(threeDelay>.1) assert(timer->isScheduled(callbackThree));
String builder;
timer->toString(&builder);
printf("timerQueue\n%s",builder.c_str());
eventOne->wait();
eventTwo->wait();
eventThree->wait();
double diff;
double delta;
diff = TimeStamp::diff(
callbackOne->getTimeStamp(),currentTimeStamp);
delta = diff - oneDelay;
fprintf(auxfd,"one requested %f actual %f delta %f\n",oneDelay,diff,delta);
if(delta<0.0) delta = -delta;
assert(delta<.1);
diff = TimeStamp::diff(
callbackTwo->getTimeStamp(),currentTimeStamp);
delta = diff - twoDelay;
fprintf(auxfd,"two requested %f actual %f delta %f\n",twoDelay,diff,delta);
if(delta<0.0) delta = -delta;
assert(delta<.1);
diff = TimeStamp::diff(
callbackThree->getTimeStamp(),currentTimeStamp);
delta = diff - threeDelay;
fprintf(auxfd,"three requested %f actual %f delta %f\n",threeDelay,diff,delta);
if(delta<0.0) delta = -delta;
assert(delta<.1);
}
}
static void testCancel(FILE *fd, FILE *auxfd)
{
printf("\n\ntestCancel oneDelay %lf twoDelay %lf threeDaley %lf\n",
oneDelay,twoDelay,threeDelay);
String one("one");
String two("two");
String three("three");
EventPtr eventOne(new Event());
EventPtr eventTwo(new Event());
EventPtr eventThree(new Event());
TimerPtr timer(new Timer(String("timer"),middlePriority));
MyCallbackPtr callbackOne(new MyCallback(one,fd,auxfd,eventOne));
MyCallbackPtr callbackTwo(new MyCallback(two,fd,auxfd,eventTwo));
MyCallbackPtr callbackThree(new MyCallback(three,fd,auxfd,eventThree));
for(int n=0; n<ntimes; n++) {
currentTimeStamp.getCurrent();
assert(!timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
assert(!timer->isScheduled(callbackThree));
timer->scheduleAfterDelay(callbackOne,oneDelay);
timer->scheduleAfterDelay(callbackTwo,twoDelay);
timer->scheduleAfterDelay(callbackThree,threeDelay);
timer->cancel(callbackTwo);
if(oneDelay>.1) assert(timer->isScheduled(callbackOne));
assert(!timer->isScheduled(callbackTwo));
if(threeDelay>.1) assert(timer->isScheduled(callbackThree));
String builder;
timer->toString(&builder);
printf("timerQueue\n%s",builder.c_str());
eventOne->wait();
eventThree->wait();
double diff;
double delta;
diff = TimeStamp::diff(
callbackOne->getTimeStamp(),currentTimeStamp);
delta = diff - oneDelay;
fprintf(auxfd,"one requested %f actual %f delta %f\n",oneDelay,diff,delta);
if(delta<0.0) delta = -delta;
assert(delta<.1);
diff = TimeStamp::diff(
callbackThree->getTimeStamp(),currentTimeStamp);
delta = diff - threeDelay;
fprintf(auxfd,"three requested %f actual %f delta %f\n",threeDelay,diff,delta);
if(delta<0.0) delta = -delta;
assert(delta<.1);
}
}
int main(int argc, char *argv[]) {
@@ -105,14 +182,24 @@ int main(int argc, char *argv[]) {
}
oneDelay = .4;
twoDelay = .2;
threeDelay = .1;
testBasic(fd,auxfd);
oneDelay = .2;
testCancel(fd,auxfd);
oneDelay = .1;
twoDelay = .2;
threeDelay = .4;
testBasic(fd,auxfd);
testCancel(fd,auxfd);
oneDelay = .1;
twoDelay = .4;
threeDelay = .2;
testBasic(fd,auxfd);
testCancel(fd,auxfd);
oneDelay = .0;
twoDelay = .0;
threeDelay = .0;
testBasic(fd,auxfd);
testCancel(fd,auxfd);
epicsExitCallAtExits();
CDRMonitor::get().show(fd);
return (0);
}

1
testApp/pv/testIntrospect.cpp
View File

@@ -20,7 +20,6 @@
#include <pv/pvIntrospect.h>
#include <pv/pvData.h>
#include <pv/standardField.h>
#include <pv/CDRMonitor.h>
using namespace epics::pvData;

2
testApp/pv/testPVStructureArray.cpp
View File

@@ -89,7 +89,7 @@ void testPowerSupplyArray(FILE * fd) {
powerSupplyArray->remove(2,1);
buffer.clear();
powerSupplyArrayStruct->toString(&buffer);
fprintf(fd,"after remove 0,1,3%s\n",buffer.c_str());
fprintf(fd,"after remove 2,1%s\n",buffer.c_str());
powerSupplyArray->compress();
buffer.clear();
powerSupplyArrayStruct->toString(&buffer);