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

backout INLINE; add level argument to semXXXShow

Browse Source
This commit is contained in:
Marty Kraimer
2000-02-01 19:40:43 +00:00
parent 48886ee4c8
commit b8d7ab2f9d
15 changed files with 287 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
src/libCom/osi/os/RTEMS/osdInterrupt.c
View File

@@ -10,6 +10,7 @@
#include <rtems.h>
#include <rtems/error.h>
#include "errlog.h"
#include "osiInterrupt.h"
#define INTERRUPT_CONTEXT_MESSAGE_QUEUE_COUNT 100

12
src/libCom/osi/os/RTEMS/osdInterrupt.h
View File

@@ -1,11 +1 @@
/*
* RTEMS osiInterrupt.h
* $Id$
* Author: W. Eric Norum
* eric@cls.usask.ca
* (306) 966-6055
*/
int interruptLock (void);
void interruptUnlock (int key);
int interruptIsInterruptContext (void);
void interruptContextMessage (const char *message);
/* osdInterrupt.h not needed */

45
src/libCom/osi/os/RTEMS/osdSem.c
View File

@@ -50,6 +50,13 @@ semBinaryCreate(int initialState)
return (semBinaryId)sid;
}
semBinaryId semBinaryMustCreate(int initialState)
{
semBinaryId id = semBinaryCreate (initialState);
assert (id);
return id;
}
void
semBinaryDestroy(semBinaryId id)
{
@@ -156,3 +163,41 @@ semMutexCreate(void)
rtems_interrupt_enable (level);
return (semMutexId)sid;
}
semMutexId semMutexMustCreate(void)
{
semMutexId id = semMutexCreate ();
assert (id);
return id;
}
void semMutexDestroy(semMutexId id)
{
semBinaryDestroy (id);
}
void semMutexGive(semMutexId id)
{
semBinaryGive (id);
}
semTakeStatus semMutexTake(semMutexId id)
{
return semBinaryTake (id);
}
semTakeStatus semMutexTakeTimeout(
semMutexId id, double timeOut)
{
return semBinaryTakeTimeout (id, timeOut);
}
semTakeStatus semMutexTakeNoWait(semMutexId id)
{
return semBinaryTakeNoWait (id);
}
epicsShareFunc void semMutexShow(semMutexId id)
{
semBinaryShow (id);
}

45
src/libCom/osi/os/RTEMS/osdSem.h
View File

@@ -5,48 +5,5 @@
* eric@cls.usask.ca
* (306) 966-6055
*/
#ifndef osdSemh
#define osdSemh
#ifdef __cplusplus
extern "C" {
#endif
#include "shareLib.h"
epicsShareFunc INLINE void epicsShareAPI semMutexDestroy(semMutexId id)
{
semBinaryDestroy (id);
}
epicsShareFunc INLINE void epicsShareAPI semMutexGive(semMutexId id)
{
semBinaryGive (id);
}
epicsShareFunc INLINE semTakeStatus epicsShareAPI semMutexTake(semMutexId id)
{
return semBinaryTake (id);
}
epicsShareFunc INLINE semTakeStatus epicsShareAPI semMutexTakeTimeout(
semMutexId id, double timeOut)
{
return semBinaryTakeTimeout (id, timeOut);
}
epicsShareFunc INLINE semTakeStatus epicsShareAPI semMutexTakeNoWait(semMutexId id)
{
return semBinaryTakeNoWait (id);
}
epicsShareFunc void epicsShareAPI semMutexShow(semMutexId id)
{
semBinaryShow (id);
}
#ifdef __cplusplus
}
#endif
#endif /*osdSemh*/
/* osdSem.h not needed */

24
src/libCom/osi/os/RTEMS/osdThread.c
View File

@@ -220,3 +220,27 @@ threadGetIdSelf (void)
rtems_task_ident (RTEMS_SELF, 0, &tid);
return (threadId)tid;
}
extern void *rtemsTaskVariable;
threadVarId threadPrivateCreate ()
{
return NULL;
}
void threadPrivateDelete ()
{
}
void threadPrivateSet (threadVarId id, void *ptr)
{
rtems_task_variable_add (RTEMS_SELF, &rtemsTaskVariable, NULL);
rtemsTaskVariable = ptr;
}
void * threadPrivateGet (threadVarId id)
{
return rtemsTaskVariable;
}
#ifdef __cplusplus
}
#endif
#endif /* osdThreadh */

36
src/libCom/osi/os/RTEMS/osdThread.h
View File

@@ -1,35 +1 @@
#ifndef osdThreadh
#define osdThreadh
#ifdef __cplusplus
extern "C" {
#endif
#include "shareLib.h"
/*
* RTEMS-specific implementation of osi thread variable routines
*/
extern void *rtemsTaskVariable;
epicsShareFunc INLINE threadVarId epicsShareAPI threadPrivateCreate ()
{
return NULL;
}
epicsShareFunc INLINE void epicsShareAPI threadPrivateDelete ()
{
}
epicsShareFunc INLINE void epicsShareAPI threadPrivateSet (threadVarId id, void *ptr)
{
rtems_task_variable_add (RTEMS_SELF, &rtemsTaskVariable, NULL);
rtemsTaskVariable = ptr;
}
epicsShareFunc INLINE void * epicsShareAPI threadPrivateGet (threadVarId id)
{
return rtemsTaskVariable;
}
#ifdef __cplusplus
}
#endif
#endif /* osdThreadh */
/* osdThread.h not needed */

18
src/libCom/osi/os/posix/osdSem.c
View File

@@ -88,6 +88,13 @@ void semBinaryDestroy(semBinaryId id)
strerror(status));
free(pbinary);
}
semBinaryId semBinaryMustCreate(int initialState)
{
semBinaryId id = semBinaryCreate (initialState);
assert (id);
return id;
}
void semBinaryGive(semBinaryId id)
{
@@ -141,7 +148,7 @@ semTakeStatus semBinaryTakeNoWait(semBinaryId id)
return(semTakeError);
}
void semBinaryShow(semBinaryId id)
void semBinaryShow(semBinaryId id,int level)
{
}
@@ -178,6 +185,13 @@ semMutexId semMutexCreate(void) {
return((semMutexId)pmutex);
}
semMutexId semMutexMustCreate(void)
{
semMutexId id = semMutexCreate ();
assert (id);
return id;
}
void semMutexDestroy(semMutexId id)
{
mutex *pmutex = (mutex *)id;
@@ -270,7 +284,7 @@ semTakeStatus semMutexTakeNoWait(semMutexId id)
return(status);
}
void semMutexShow(semMutexId id)
void semMutexShow(semMutexId id,int level)
{
mutex *pmutex = (mutex *)id;
printf("ownerTid %p count %d owned %d\n",

18
src/libCom/osi/os/vxWorks/osdInterrupt.c
View File

@@ -7,4 +7,20 @@ This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
static void dummy() {}
#include <vxWorks.h>
#include <intLib.h>
#include <logLib.h>
#include "osiInterrupt.h"
int interruptLock() {return(intLock());}
void interruptUnlock(int key) {intUnlock(key);}
int interruptIsInterruptContext() {return(intContext());}
void interruptContextMessage(const char *message)
{
logMsg((char *)message,0,0,0,0,0,0);
}

16
src/libCom/osi/os/vxWorks/osdInterrupt.h
View File

@@ -7,18 +7,4 @@ This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <vxWorks.h>
#include <intLib.h>
#include <logLib.h>
epicsShareFunc INLINE int interruptLock() {return(intLock());}
epicsShareFunc INLINE void interruptUnlock(int key) {intUnlock(key);}
epicsShareFunc INLINE int interruptIsInterruptContext() {return(intContext());}
epicsShareFunc INLINE void interruptContextMessage(const char *message)
{
logMsg((char *)message,0,0,0,0,0,0);
}
/*osdInterrupt.h not needed */

56
src/libCom/osi/os/vxWorks/osdRing.c
View File

@@ -7,4 +7,58 @@ This software was developed under a United States Government license
described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
static void dummy(){}
#include <vxWorks.h>
#include <rngLib.h>
#include "osiRing.h"
ringId ringCreate(int nbytes)
{
return((ringId)rngCreate(nbytes));
}
void ringDelete(ringId id)
{
rngDelete((RING_ID)id);
}
int ringGet(ringId id, char *value,int nbytes)
{
return(rngBufGet((RING_ID)id,value,nbytes));
}
int ringPut(ringId id, char *value,int nbytes)
{
return(rngBufPut((RING_ID)id,value,nbytes));
}
void ringFlush(ringId id)
{
ringFlush((RING_ID)id);
}
int ringFreeBytes(ringId id)
{
return(rngFreeBytes((RING_ID)id));
}
int ringUsedBytes(ringId id)
{
return(rngNBytes((RING_ID)id));
}
int ringSize(ringId id)
{
return((rngFreeBytes((RING_ID)id) + rngNBytes((RING_ID)id)));
}
int ringIsEmpty(ringId id)
{
return(rngIsEmpty((RING_ID)id));
}
int ringIsFull(ringId id)
{
return(rngIsFull((RING_ID)id));
}

53
src/libCom/osi/os/vxWorks/osdRing.h
View File

@@ -8,55 +8,4 @@ described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <vxWorks.h>
#include <rngLib.h>
epicsShareFunc INLINE ringId ringCreate(int nbytes)
{
return((ringId)rngCreate(nbytes));
}
epicsShareFunc INLINE void ringDelete(ringId id)
{
rngDelete((RING_ID)id);
}
epicsShareFunc INLINE int ringGet(ringId id, char *value,int nbytes)
{
return(rngBufGet((RING_ID)id,value,nbytes));
}
epicsShareFunc INLINE int ringPut(ringId id, char *value,int nbytes)
{
return(rngBufPut((RING_ID)id,value,nbytes));
}
epicsShareFunc INLINE void ringFlush(ringId id)
{
ringFlush((RING_ID)id);
}
epicsShareFunc INLINE int ringFreeBytes(ringId id)
{
return(rngFreeBytes((RING_ID)id));
}
epicsShareFunc INLINE int ringUsedBytes(ringId id)
{
return(rngNBytes((RING_ID)id));
}
epicsShareFunc INLINE int ringSize(ringId id)
{
return((rngFreeBytes((RING_ID)id) + rngNBytes((RING_ID)id)));
}
epicsShareFunc INLINE int ringIsEmpty(ringId id)
{
return(rngIsEmpty((RING_ID)id));
}
epicsShareFunc INLINE int ringIsFull(ringId id)
{
return(rngIsFull((RING_ID)id));
}
/* osdRing.h not needed */

117
src/libCom/osi/os/vxWorks/osdSem.c
View File

@@ -8,4 +8,119 @@ described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
static void dummy(){}
#include <vxWorks.h>
#include <semLib.h>
#include <time.h>
#include <objLib.h>
#include <sysLib.h>
#include "osiSem.h"
semBinaryId semBinaryCreate(int initialState)
{
return((semBinaryId)semBCreate(SEM_Q_FIFO,(semEmpty ? SEM_EMPTY : SEM_FULL)));
}
semBinaryId semBinaryMustCreate(int initialState)
{
semBinaryId id = semBinaryCreate (initialState);
assert (id);
return id;
}
void semBinaryDestroy(semBinaryId id)
{
semDelete((SEM_ID)id);
}
void semBinaryGive(semBinaryId id)
{
semGive((SEM_ID)id);
}
semTakeStatus semBinaryTake(semBinaryId id)
{
int status;
status = semTake((SEM_ID)id,WAIT_FOREVER);
return((status==OK ? semTakeOK : semTakeError));
}
semTakeStatus semBinaryTakeTimeout(
semBinaryId id, double timeOut)
{
int status;
int ticks;
ticks = (int)(timeOut * (double)sysClkRateGet());
status = semTake((SEM_ID)id,ticks);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_TIMEOUT) return(semTakeTimeout);
return(semTakeError);
}
semTakeStatus semBinaryTakeNoWait(semBinaryId id)
{
int status;
status = semTake((SEM_ID)id,NO_WAIT);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_UNAVAILABLE) return(semTakeTimeout);
return(semTakeError);
}
void semBinaryShow(semBinaryId id, int level)
{
semShow((SEM_ID)id,level);
}
semMutexId semMutexCreate(void)
{
return((semMutexId)
semMCreate(SEM_DELETE_SAFE|SEM_INVERSION_SAFE|SEM_Q_PRIORITY));
}
semMutexId semMutexMustCreate(void)
{
semMutexId id = semMutexCreate ();
assert (id);
return id;
}
void semMutexDestroy(semMutexId id)
{
semDelete((SEM_ID)id);
}
void semMutexGive(semMutexId id)
{
semGive((SEM_ID)id);
}
semTakeStatus semMutexTake(semMutexId id)
{
int status;
status = semTake((SEM_ID)id,WAIT_FOREVER);
return((status==OK ? semTakeOK : semTakeError));
}
semTakeStatus semMutexTakeTimeout(
semMutexId id, double timeOut)
{
int status;
status = semTake((SEM_ID)id,NO_WAIT);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_UNAVAILABLE) return(semTakeTimeout);
return(semTakeError);
}
semTakeStatus semMutexTakeNoWait(semMutexId id)
{
int status;
status = semTake((SEM_ID)id,NO_WAIT);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_UNAVAILABLE) return(semTakeTimeout);
return(semTakeError);
}
void semMutexShow(semMutexId id, int level)
{
semShow((SEM_ID)id,level);
}

101
src/libCom/osi/os/vxWorks/osdSem.h
View File

@@ -8,103 +8,4 @@ described on the COPYRIGHT_UniversityOfChicago file included as part
of this distribution.
****************************************************************************/
#include <vxWorks.h>
#include <semLib.h>
#include <time.h>
#include <objLib.h>
#include <sysLib.h>
epicsShareFunc INLINE semBinaryId semBinaryCreate(int initialState)
{
return((semBinaryId)semBCreate(SEM_Q_FIFO,(semEmpty ? SEM_EMPTY : SEM_FULL)));
}
epicsShareFunc INLINE void semBinaryDestroy(semBinaryId id)
{
semDelete((SEM_ID)id);
}
epicsShareFunc INLINE void semBinaryGive(semBinaryId id)
{
semGive((SEM_ID)id);
}
epicsShareFunc INLINE semTakeStatus semBinaryTake(semBinaryId id)
{
int status;
status = semTake((SEM_ID)id,WAIT_FOREVER);
return((status==OK ? semTakeOK : semTakeError));
}
epicsShareFunc INLINE semTakeStatus semBinaryTakeTimeout(
semBinaryId id, double timeOut)
{
int status;
int ticks;
ticks = (int)(timeOut * (double)sysClkRateGet());
status = semTake((SEM_ID)id,ticks);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_TIMEOUT) return(semTakeTimeout);
return(semTakeError);
}
epicsShareFunc INLINE semTakeStatus semBinaryTakeNoWait(semBinaryId id)
{
int status;
status = semTake((SEM_ID)id,NO_WAIT);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_UNAVAILABLE) return(semTakeTimeout);
return(semTakeError);
}
epicsShareFunc INLINE void semBinaryShow(semBinaryId id)
{
semShow((SEM_ID)id,1);
}
epicsShareFunc INLINE semMutexId semMutexCreate(void)
{
return((semMutexId)
semMCreate(SEM_DELETE_SAFE|SEM_INVERSION_SAFE|SEM_Q_PRIORITY));
}
epicsShareFunc INLINE void semMutexDestroy(semMutexId id)
{
semDelete((SEM_ID)id);
}
epicsShareFunc INLINE void semMutexGive(semMutexId id)
{
semGive((SEM_ID)id);
}
epicsShareFunc INLINE semTakeStatus semMutexTake(semMutexId id)
{
int status;
status = semTake((SEM_ID)id,WAIT_FOREVER);
return((status==OK ? semTakeOK : semTakeError));
}
epicsShareFunc INLINE semTakeStatus semMutexTakeTimeout(
semMutexId id, double timeOut)
{
int status;
status = semTake((SEM_ID)id,NO_WAIT);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_UNAVAILABLE) return(semTakeTimeout);
return(semTakeError);
}
epicsShareFunc INLINE semTakeStatus semMutexTakeNoWait(semMutexId id)
{
int status;
status = semTake((SEM_ID)id,NO_WAIT);
if(status==OK) return(semTakeOK);
if(errno==S_objLib_OBJ_UNAVAILABLE) return(semTakeTimeout);
return(semTakeError);
}
epicsShareFunc INLINE void semMutexShow(semMutexId id)
{
semShow((SEM_ID)id,1);
}
/* no osdSem.h definitions are needed */

43
src/libCom/osi/osiSem.h
View File

@@ -1,7 +1,7 @@
#ifndef osiSemh
#define osiSemh
#include <assert.h>
#include <epicsAssert.h>
#ifdef __cplusplus
extern "C" {
@@ -19,11 +19,11 @@ epicsShareFunc semBinaryId epicsShareAPI semBinaryMustCreate (
epicsShareFunc void epicsShareAPI semBinaryDestroy(semBinaryId id);
epicsShareFunc void epicsShareAPI semBinaryGive(semBinaryId id);
epicsShareFunc semTakeStatus epicsShareAPI semBinaryTake(semBinaryId id);
epicsShareFunc void epicsShareAPI semBinaryMustTake (semBinaryId id);
#define semBinaryMustTake(ID) assert((semBinaryTake ((ID))==semTakeOK))
epicsShareFunc semTakeStatus epicsShareAPI semBinaryTakeTimeout(
semBinaryId id, double timeOut);
epicsShareFunc semTakeStatus epicsShareAPI semBinaryTakeNoWait(semBinaryId id);
epicsShareFunc void epicsShareAPI semBinaryShow(semBinaryId id);
epicsShareFunc void epicsShareAPI semBinaryShow(semBinaryId id, int level);
typedef void *semMutexId;
epicsShareFunc semMutexId epicsShareAPI semMutexCreate(void);
@@ -31,11 +31,11 @@ epicsShareFunc semMutexId epicsShareAPI semMutexMustCreate (void);
epicsShareFunc void epicsShareAPI semMutexDestroy(semMutexId id);
epicsShareFunc void epicsShareAPI semMutexGive(semMutexId id);
epicsShareFunc semTakeStatus epicsShareAPI semMutexTake(semMutexId id);
epicsShareFunc void epicsShareAPI semMutexMustTake(semMutexId id);
#define semMutexMustTake(ID) assert((semMutexTake((ID))==semTakeOK))
epicsShareFunc semTakeStatus epicsShareAPI semMutexTakeTimeout(
semMutexId id, double timeOut);
epicsShareFunc semTakeStatus epicsShareAPI semMutexTakeNoWait(semMutexId id);
epicsShareFunc void epicsShareAPI semMutexShow(semMutexId id);
epicsShareFunc void epicsShareAPI semMutexShow(semMutexId id, int level);
/*NOTES:
Mutex semaphores MUST implement recursive locking
@@ -48,37 +48,4 @@ epicsShareFunc void epicsShareAPI semMutexShow(semMutexId id);
#include "osdSem.h"
#ifdef __cplusplus
extern "C" {
#endif
epicsShareFunc INLINE semBinaryId epicsShareAPI semBinaryMustCreate (
int initialState)
{
semBinaryId id = semBinaryCreate (initialState);
assert (id);
return id;
}
epicsShareFunc INLINE void epicsShareAPI semBinaryMustTake (semBinaryId id)
{
assert (semBinaryTake (id)==semTakeOK);
}
epicsShareFunc INLINE semMutexId epicsShareAPI semMutexMustCreate (void)
{
semMutexId id = semMutexCreate ();
assert (id);
return id;
}
epicsShareFunc INLINE void epicsShareAPI semMutexMustTake(semMutexId id)
{
assert (semMutexTake (id)==semTakeOK);
}
#ifdef __cplusplus
}
#endif
#endif /* osiSemh */

4
src/libCom/test/semMutexTest.c
View File

@@ -75,14 +75,14 @@ void semMutexTest(int nthreads)
printf("calling semMutexTakeNoWait(mutex) time %d\n",time(&tp));
status = semMutexTakeNoWait(mutex);
if(status) printf("status %d\n",status);
semMutexShow(mutex);
semMutexShow(mutex,1);
printf("calling semMutexGive() time %d\n",time(&tp));
semMutexGive(mutex);
printf("calling semMutexGive() time %d\n",time(&tp));
semMutexGive(mutex);
printf("calling semMutexGive() time %d\n",time(&tp));
semMutexGive(mutex);
semMutexShow(mutex);
semMutexShow(mutex,1);
if(nthreads<=0) return;
id = calloc(nthreads,sizeof(threadId));