epics/epics-base
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

replacements for osdSem

Browse Source
This commit is contained in:
Marty Kraimer
2000-12-20 21:02:04 +00:00
parent a5ee8cf64a
commit d3c0f075cf
22 changed files with 2099 additions and 2 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libCom/test/Makefile
+10
View File
@@ -14,14 +14,24 @@ ringPointerTestHost_SRCS += ringPointerTestMain.c ringPointerTest.c
PROD += ringPointerTestHost
OBJS_IOC += ringPointerTest
# Marty remover the following
semBinaryTestHost_SRCS += semBinaryTestMain.c semBinaryTest.c
PROD += semBinaryTestHost
OBJS_IOC += semBinaryTest
# Marty remover the following
semMutexTestHost_SRCS += semMutexTestMain.c semMutexTest.c
PROD += semMutexTestHost
OBJS_IOC += semMutexTest
epicsEventTestHost_SRCS += epicsEventTestMain.cpp epicsEventTest.cpp
PROD += epicsEventTestHost
OBJS_IOC += epicsEventTest
epicsMutexTestHost_SRCS += epicsMutexTestMain.cpp epicsMutexTest.cpp
PROD += epicsMutexTestHost
OBJS_IOC += epicsMutexTest
threadTestHost_SRCS += threadTestMain.c threadTest.c
PROD += threadTestHost
OBJS_IOC += threadTest
src/libCom/test/epicsEventTest.cpp
+168
View File
@@ -0,0 +1,168 @@
/* epicsEventTest.cpp */
/* Author: Marty Kraimer Date: 26JAN2000 */
/********************COPYRIGHT NOTIFICATION**********************************
This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <stddef.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include "osiThread.h"
#include "epicsEvent.h"
#include "epicsMutex.h"
#include "epicsRingPointer.h"
#include "errlog.h"
typedef struct info {
epicsEventId event;
epicsMutexId lockRing;
int quit;
epicsRingPointerId ring;
}info;
static void consumer(void *arg)
{
info *pinfo = (info *)arg;
time_t tp;
threadId idSelf = threadGetIdSelf();
printf("consumer %p starting time %ld\n",idSelf,time(&tp));
while(1) {
epicsEventWaitStatus status;
if(pinfo->quit) {
printf("consumer %p returning time %ld\n",
idSelf,time(&tp));
return;
}
status = epicsEventWait(pinfo->event);
if(status!=epicsEventWaitOK) {
printf("task %p epicsEventWait returned %d time %ld\n",
idSelf,(int)status,time(&tp));
}
while(epicsRingPointerGetUsed(pinfo->ring)>=2) {
threadId message[2];
int i;
for(i=0; i<2; i++) {
if(!(message[i]=epicsRingPointerPop(pinfo->ring)))
printf("consumer error\n");
}
if(message[0]!=message[1]) {
printf("consumer error message %p %p\n",message[0],message[1]);
} else {
printf("consumer message from %p\n",message[0]);
}
}
}
}
static void producer(void *arg)
{
info *pinfo = (info *)arg;
time_t tp;
threadId idSelf = threadGetIdSelf();
int ntimes=0;
printf("producer %p starting time %ld\n",idSelf,time(&tp));
while(1) {
epicsMutexLockStatus status;
++ntimes;
if(pinfo->quit) {
printf("producer %p returning time %ld\n",
idSelf,time(&tp));
return;
}
status = epicsMutexLock(pinfo->lockRing);
if(status!=epicsMutexLockOK) {
printf("producer %p epicsMutexLock returned %d time %ld\n",
idSelf,(int)status,time(&tp));
}
if(epicsRingPointerGetFree(pinfo->ring)>=2) {
int i;
for(i=0; i<2; i++) {
if(!epicsRingPointerPush(pinfo->ring,idSelf))
printf("producer %p error\n",idSelf);
if(i==0 && (ntimes%4==0)) threadSleep(.1);
}
printf("producer %p sending\n",idSelf);
} else {
printf("producer %p ring buffer is full\n",idSelf);
}
epicsMutexUnlock(pinfo->lockRing);
threadSleep(1.0);
epicsEventSignal(pinfo->event);
}
}
extern "C" void epicsEventTest(int nthreads,int verbose)
{
unsigned int stackSize;
threadId *id;
char **name;
int i;
info *pinfo;
epicsEventId event;
int status;
time_t tp;
int errVerboseSave = errVerbose;
threadInit ();
errVerbose = verbose;
event = epicsEventMustCreate(epicsEventEmpty);
printf("calling epicsEventWaitWithTimeout(event,2.0) time %ld\n",time(&tp));
status = epicsEventWaitWithTimeout(event,2.0);
if(status!=epicsEventWaitTimeout) printf("status %d\n",status);
printf("calling epicsEventTryWait(event) time %ld\n",time(&tp));
status = epicsEventTryWait(event);
if(status!=epicsEventWaitTimeout) printf("status %d\n",status);
printf("calling epicsEventSignal() time %ld\n",time(&tp));
epicsEventSignal(event);
printf("calling epicsEventWaitWithTimeout(event,2.0) time %ld\n",time(&tp));
status = epicsEventWaitWithTimeout(event,2.0);
if(status) printf("status %d\n",status);
printf("calling epicsEventSignal() time %ld\n",time(&tp));
epicsEventSignal(event);
printf("calling epicsEventTryWait(event) time %ld\n",time(&tp));
status = epicsEventTryWait(event);
if(status) printf("status %d\n",status);
if(nthreads<=0) {
errVerbose = errVerboseSave;
return;
}
pinfo = (info *)calloc(1,sizeof(info));
pinfo->event = event;
pinfo->lockRing = epicsMutexCreate();
pinfo->ring = epicsRingPointerCreate(1024*2);
stackSize = threadGetStackSize(threadStackSmall);
threadCreate("consumer",50,stackSize,consumer,pinfo);
id = (threadId *)calloc(nthreads,sizeof(threadId));
name = (char **)calloc(nthreads,sizeof(char *));
for(i=0; i<nthreads; i++) {
name[i] = (char *)calloc(10,sizeof(char));
sprintf(name[i],"producer%d",i);
id[i] = threadCreate(name[i],40,stackSize,producer,pinfo);
printf("created producer %d id %p time %ld\n",
i, id[i],time(&tp));
}
threadSleep(5.0);
printf("semTest setting quit time %ld\n",time(&tp));
pinfo->quit = 1;
threadSleep(2.0);
epicsEventSignal(pinfo->event);
threadSleep(1.0);
printf("semTest returning time %ld\n",time(&tp));
errVerbose = errVerboseSave;
}
src/libCom/test/epicsEventTestMain.cpp
+46
View File
@@ -0,0 +1,46 @@
/* epicsEventTestMain.cpp */
/* Author: Marty Kraimer Date: 26JAN2000 */
/********************COPYRIGHT NOTIFICATION**********************************
This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <stddef.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "osiThread.h"
extern "C" void epicsEventTest(int nthreads,int errVerbose);
int main(int argc,char *argv[])
{
int nthreads = 2;
int errVerbose = 0;
if(argc>1) {
if(isdigit(*argv[1])) {
sscanf(argv[1],"%d",&nthreads);
printf("nthreads %d\n",nthreads);
} else {
printf("Illegal argument %s\n",argv[1]);
}
}
if(argc>2) {
if(isdigit(*argv[2])) {
sscanf(argv[2],"%d",&errVerbose);
printf("errVerbose %d\n",errVerbose);
} else {
printf("Illegal argument %s\n",argv[1]);
}
}
epicsEventTest(nthreads,errVerbose);
printf("main terminating\n");
return(0);
}
src/libCom/test/epicsMutexTest.cpp
+116
View File
@@ -0,0 +1,116 @@
/* epicsMutexTest.c */
/* Author: Marty Kraimer Date: 26JAN2000 */
/********************COPYRIGHT NOTIFICATION**********************************
This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <stddef.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <errno.h>
#include <time.h>
#include "osiThread.h"
#include "epicsMutex.h"
#include "errlog.h"
typedef struct info {
int threadnum;
epicsMutexId mutex;
int quit;
}info;
static void mutexThread(void *arg)
{
info *pinfo = (info *)arg;
time_t tp;
printf("mutexThread %d starting time %ld\n",pinfo->threadnum,time(&tp));
while(1) {
epicsMutexLockStatus status;
if(pinfo->quit) {
printf("mutexThread %d returning time %ld\n",
pinfo->threadnum,time(&tp));
return;
}
status = epicsMutexLock(pinfo->mutex);
if(status!=epicsMutexLockOK) {
printf("task %d epicsMutexLock returned %d time %ld\n",
pinfo->threadnum,(int)status,time(&tp));
}
printf("mutexThread %d epicsMutexLock time %ld\n",
pinfo->threadnum,time(&tp));
threadSleep(.1);
epicsMutexUnlock(pinfo->mutex);
threadSleep(.9);
}
}
extern "C" void epicsMutexTest(int nthreads,int verbose)
{
unsigned int stackSize;
threadId *id;
int i;
char **name;
void **arg;
info **pinfo;
epicsMutexId mutex;
int status;
time_t tp;
int errVerboseSave = errVerbose;
threadInit ();
errVerbose = verbose;
mutex = epicsMutexMustCreate();
printf("calling epicsMutexLock(mutex) time %ld\n",time(&tp));
status = epicsMutexLock(mutex);
if(status) printf("status %d\n",status);
printf("calling epicsMutexLockWithTimeout(mutex,2.0) time %ld\n",time(&tp));
status = epicsMutexLockWithTimeout(mutex,2.0);
if(status) printf("status %d\n",status);
printf("calling epicsMutexTryLock(mutex) time %ld\n",time(&tp));
status = epicsMutexTryLock(mutex);
if(status) printf("status %d\n",status);
epicsMutexShow(mutex,1);
printf("calling epicsMutexUnlock() time %ld\n",time(&tp));
epicsMutexUnlock(mutex);
printf("calling epicsMutexUnlock() time %ld\n",time(&tp));
epicsMutexUnlock(mutex);
printf("calling epicsMutexUnlock() time %ld\n",time(&tp));
epicsMutexUnlock(mutex);
epicsMutexShow(mutex,1);
if(nthreads<=0) {
errVerbose = errVerboseSave;
return;
}
id = (void **)calloc(nthreads,sizeof(threadId));
name = (char **)calloc(nthreads,sizeof(char *));
arg = (void **)calloc(nthreads,sizeof(void *));
pinfo = (info **)calloc(nthreads,sizeof(info *));
stackSize = threadGetStackSize(threadStackSmall);
for(i=0; i<nthreads; i++) {
name[i] = (char *)calloc(10,sizeof(char));
sprintf(name[i],"task%d",i);
pinfo[i] = (info *)calloc(1,sizeof(info));
pinfo[i]->threadnum = i;
pinfo[i]->mutex = mutex;
arg[i] = pinfo[i];
id[i] = threadCreate(name[i],40,stackSize,(THREADFUNC)mutexThread,arg[i]);
printf("semTest created mutexThread %d id %p time %ld\n",
i, id[i],time(&tp));
}
threadSleep(5.0);
printf("semTest setting quit time %ld\n",time(&tp));
for(i=0; i<nthreads; i++) {
pinfo[i]->quit = 1;
}
threadSleep(2.0);
errVerbose = errVerboseSave;
}
src/libCom/test/epicsMutexTestMain.cpp
+46
View File
@@ -0,0 +1,46 @@
/* epicsMutexTestMain.c */
/* Author: Marty Kraimer Date: 26JAN2000 */
/********************COPYRIGHT NOTIFICATION**********************************
This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <stddef.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <stdio.h>
#include <ctype.h>
#include "osiThread.h"
extern "C" void epicsMutexTest(int nthreads,int errVerbose);
int main(int argc,char *argv[])
{
int nthreads = 2;
int errVerbose = 0;
if(argc>1) {
if(isdigit(*argv[1])) {
sscanf(argv[1],"%d",&nthreads);
printf("nthreads %d\n",nthreads);
} else {
printf("Illegal argument %s\n",argv[1]);
}
}
if(argc>2) {
if(isdigit(*argv[2])) {
sscanf(argv[2],"%d",&errVerbose);
printf("errVerbose %d\n",errVerbose);
} else {
printf("Illegal argument %s\n",argv[1]);
}
}
epicsMutexTest(nthreads,errVerbose);
printf("main terminating\n");
return(0);
}