Experimental Physics and
Industrial Control System

Work on porting iocCore to other operating systems besides vxWorks is
progressing.

The following has been accomplised

Almost all of base except Channel Access, the sequencer, and hardware support
has been changed to use the new osi routines rather than vxWorks specific calls.
I have not touched Channel Access becuse this needs help from Jeff Hill. William
Lupton is already working on a version of the sequencer that is independent of
vxWorks. The hardware dependent code will be unbundled from base.

Janet Anderson has modified the make system so that it works for non vxWorks IOC
targets. The new system is actually easier than the old.

Using the new osi independent code the example application generated by
makeBaseApp has been run successfully. This was a major milestone.

A document describing the iocCore port is attached. Note that to port to other
systems only the libraries osiSem and osiThread need to be implemented. It
should be possible to implement these using posix calls. If this is done we
should be able to run iocCore on many platforms.

Marty Kraimer

Porting iocCore

Sept 10, 1999

• Database locking, scanning, and processing
• Channel access client and server support
• Standard record types and soft device support
• Access security
• Other non-hardware support presently packaged with base

The port is based on the following assumptions:

• All hardware support  is unbundled from base and thus does not need to be ported.
• For iocCore a multithreaded environment is necessary.
• osi  components are defined such that
• vxWorks implementation has minimal overhead compared to vxWorks specific calls
• The components can be implemented via a combination of POSIX, POSIX.4 (posix real time), and POSIX threads (pthreads).
• For components that require different implementation for different environments
• The implementation may be via header and/or source files as long as user code can use the "prototype" header files.

Overview of Changes

Replacements for existing vxWorks and epics components

• osiClock

replaces tickGet, sysClockRateGet, TSgetTimeStamp and TSgetCurrentTime.
A generic and a vxWorks version is available
• osiFindGlobalSymbol

A generic version is provided that always returns failure.
a vxWorks version is provided that calls symFindByName.
• osiInterrupt

Replaces intLib
A generic version is provided that uses a global semaphore. It can be used for winXX, Unix, Linux, etc.
A vxWorks specific version is provided.
• osiRing

Replaces rngLib.
A generic version usable on all platforms is provided.
A vxWorks specific version is provided.
• osiSem

replaces semLib.h
A vxWorks version is provided.
No version has been written for other platforms.
• osiThread

replaces taskLib.h
A vxWorks version is provided.
No version exists for other platforms.
• osiWatchdog

replaces wdLib.h
A vxWorks version is provided.
No version exists for other platforms.

• cantProceed

This is called by code that doesnt know what to do when an error occurs.
• registry

replaces symFindByName

Registry

• Each "ioc" loads a single dbd file defining the complete set of record types, device support, and drivers for that "ioc". A utility is provided that reads this dbd file and generates a C routine registerRecordDeviceDriver, which registers the record,  device, and driver support.
• dbLoadDatabase calls registerRecordDeviceDriver after loading the database.
• A version of registerRecordDeviceSupport is also provided which calls osiFindGlobalSymbol. If the underlying operating system properly implements  osiFindGlobalSymbol, this version can be used without running the utility that generates the special version. For example this version works on vxWorks
• Nothing has been done to support things like subroutine records. It should not be hard.

Build Environment (Everyone's favorite subject :-)

• Each source directory has a single Makefile. This build for both the host and for all IOC targets
• The new configuration files are located in base/configure
• At least for awhile base/config is still present so that old applications still build without major changes

UNRESOLVED ISSUE: Should we have the ability to distinguish building for a single vw multithreaded environment? My guess is YES.

task_params.h

• Thread names are determined by code that calls threadCreate
• Priorites and stack sizes are handled as described below in the description of thread
• Task creation options are  determined by each platform specific version of thread.

vxWorks shell

How do we run dbpr, dbgf, etc?

Interrupt Level

Status Of Port

• All code except Channel Access, Sequencer, and vxWorks dependent device and driver support has been converted to use the new libraries
• The registry has been implemented
• The example generated by makeBaseApp has been successfully tested on vxWorks.
• A separate subdirectory base/src/vxWorks has been created and all vxWorks specific code moved to this subdirectory. This makes it possible for existing vxWorks ioc applications to use the new system with only minor changes to the applications.

Work Remaining

• Implement osiSem and osiThread for other platforms. If the implementation is done via posix (including posix real time and posix threads) then many platforms should be supported.
• Convert Channel Access (client and server) to use osi calls.
• Convert the sequencer to use osi calls. William Lupton has already implemented an alpha version. Also the sequencer will be unbundled from base.
• Finish the config and Makefile Changes.
• Modify makeBaseApp so that it uses the new method of building
• TEST TEST TEST

Prototype Definitions

A particular implementation may implement each function as desired BUT the final result must appear to user code like the definitions in this section. For example  functions can be implemented via macros defined in a header file that replace the generic header file.
 

osiClock

unsigned long clockGetCurrentTick();
int clockGetRate();
int clockGetEventTime(int event_number,TS_STAMP *ts);
int clockGetCurrentTime(TS_STAMP* ts);

A generic version is provided that should work on most platforms.

Perhaps it should be implemented via libCom/osiTime.

osiFindGlobalSymbol

void * osiFindGlobalSymbol(const char *name);

A generic version is provided that always returns failure. If the generic version is used then all external symbols must be registered, See the registry for details.

osiInterrupt

int interruptLock();
void interruptUnlock(int key);
int interruptIsInterruptContext();
void interruptContextMessage(const char *message);

A generic version is provided that uses a global semaphore to lock. This version is intended for operating systems in which iocCore will run as a multithreaded process. The global semaphore is thus only global within the process.

osiRing

ringId  ringCreate(int nbytes);
void    ringDelete(ringId id);
int     ringGet(ringId id, char *value,int nbytes);
int     ringPut(ringId id, char *value,int nbytes);
void    ringFlush(ringId id);
int     ringFreeBytes(ringId id);
int     ringUsedBytes(ringId id);
int     ringSize(ringId id);
int     ringIsEmpty(ringId id);
int     ringIsFull(ringId id);

A generic version is provided that works on all platforms.  This version is currently 1.5 times slower than the vxWorks specific version. Perhaps some clever thought can make it as fast as rngLib.

osiRing has the following properties.

• For a single writer it is not necessary to lock puts
• For a single reader it is not necessary to lock gets

ringFlush should only be used if both gets and puts are locked.

osiSem.h

typedef void *semId;
typedef enum {semTakeOK,semTakeTimeout} semTakeStatus;
typedef enum {semEmpty,semFull} semInitialState;

semId semBinaryCreate(int initialState);
void semBinaryDestroy(semId id);
void semBinaryGive(semId id);
semTakeStatus semBinaryTake(semId id);
void semBinaryTakeAssert(semId id);
semTakeStatus semBinaryTakeTimeout(semId id, double timeOut);
semTakeStatus semBinaryTakeNoWait(semId id);
void semBinaryFlush(semId id);

semId semMutexCreate(void);
void semMutexDestroy(semId id);
void semMutexGive(semId id);
semTakeStatus semMutexTake(semId id);
void semMutexTakeAssert(semId id);
semTakeStatus semMutexTakeTimeout(semId id, double timeOut);
semTakeStatus semMutexTakeNoWait(semId id);
void semMutexFlush(semId id);

Mutual exclusion semaphores

• MUST implement recursive locking
• SHOULD implement priority inheritance and be deletion safe

• Binary can be implemented easily as a condition variable
• Mutex can be implemented via various POSIX facilities. Takes careful thought. A pthread mutex is not sufficient.

• the entire implementation of  Binary and Mutex is via macros in a vxWorks specific header file.

On a single threaded environment

• Mutex and context are implemented as though the caller always has access to the resource.
• Binary issues an error message and terminates if an attempt is made to create an instance.

osiThread

#define threadPriorityMax 99
#define threadPriorityMin  0

/*some generic values */
#define threadPriorityLow 10
#define threadPriorityMedium 50
#define threadPriorityHigh 90


/*some iocCore specific values */
#define threadPriorityChannelAccessClient 10
#define threadPriorityChannelAccessServer 20
#define threadPriorityScanLow 60
#define threadPriorityScanHigh 70

/*
 *The following functions convert to/from osi (operating system independent)
 * and oss (operating system specific) priority values
 * NOTE THAT ALL OTHER CALLS USE osi priority values
*/

int threadGetOsiPriorityValue(int ossPriority);
int threadGetOssPriorityValue(int osiPriority);

/* stack sizes for each stackSizeClass are implementation and CPU dependent */
typedef enum {
    threadStackSmall, threadStackMedium, threadStackBig
} threadStackSizeClass;

unsigned int threadGetStackSize(threadStackSizeClass size);

typedef void *threadId;
threadId threadCreate(const char *name,
    unsigned int priority, unsigned int stackSize,
    THREADFUNC funptr,void *parm);
void threadDestroy(threadId id);
void threadSuspend(threadId id);
void threadResume(threadId id);
int threadGetPriority(threadId id);
void threadSetPriority(threadId id,int priority);
void threadSetDestroySafe(threadId id);
void threadSetDestroyUnsafe(threadId id);
const char *threadGetName(threadId id);
int threadIsEqual(threadId id1, threadId id2);
int threadIsReady(threadId id);
int threadIsSuspended(threadId id);
void threadSleep(double seconds);
threadId threadGetIdSelf(void);
void threadLockContextSwitch(void);
void threadUnlockContextSwitch(void);
threadId threadNameToId(const char *name);

Thread stack values are handled as follows:

• threadGetStackSize cal be called to get one of three default sizes. Thus should be done whenever possible.
• Code can just set any size it desires. Such code is not portable.

For posix it should be possible (I hope)  to implement thread via a combination of:

• osiSem
• pthread and POSIX.4
• Special code

osiWatchdog

typedef void *watchdogId;
typedef void (*WATCHDOGFUNC)(void *parm);

watchdogId watchdogCreate ();
void watchdogDestroy (watchdogId id);
void watchdogStart(watchdogId id, int delaySeconds,WATCHDOGFUNC funptr,*parm);
void watchdogCancel(watchdogId id);

I think a generic version can be implemented via base/srcf/libCom/osiTimer. This has not yet been implemented.

New base supplied component

cantProceed

void cantProceed(const char *errorMessage);
void *callocMustSucceed(size_t count, size_t size, const char *errorMessage);
void *mallocMustSucceed(size_t size, const char *errorMessage);

• For a threaded environment suspends. This is for debugging purposes.
• For a non-threaded environment exits.

REGISTRY

• record/device/driver support.

The registration facility provides a safe and easy to use alternative to symFindByName
• subroutine record subroutines.

An easy to use solution must be developed.
• initHooks

A new implementation of initHooks is now provided. It provides a routine initHookRegister. This MUST be called by any routine that wants to be called during initialization.
• devLib

This has been moved to base/src/vxWorks. Thus for now it is only supported on vxWorks
• drvTS.c

This has been moved to base/src/vxWorks. Thus for now it is only supported on vxWorks
• errSymLib.c

This was rewritten to be independent of vxWorks.
• epicsDynLink - obsolete. Gone.
• dev/symbDev

Moved to base/src/vxWorks. Thus for now it is only supported on vxWorks.
• any hardware related component

Either moved to base/src/vxWorks. or unbundled from base.

Overview

A perl script is provided that reads the xxxApp.dbd file and produces a c file containing a routine registerRecordDeviceDriver, which registers all record/device/driver support defined in the xxxApp.dbd file.

registry

int registryAdd(void *registryID,const char *name,void *data);
void *registryFind(void *registryID,const char *name);

int registrySetTableSize(int size);
void registryFree();
int registryDump(void);

Routine registrySetTableSize is provided in case the default hash table size (1024 entries)  is not sufficient.

registryRecordType.h

typedef int (*computeSizeOffset)(dbRecordType *pdbRecordType);

typedef struct recordTypeLocation {
    struct rset *prset;
    computeSizeOffset sizeOffset;
}recordTypeLocation;


int registryRecordTypeAdd(const char *name,recordTypeLocation *prtl);
recordTypeLocation *registryRecordTypeFind(const char *name);

• Access to both the record support entry table and to the routine which computes the size and offset of each field are provided
• Type safe access is provided.

registryDeviceSupport

int registryDeviceSupportAdd(const char *name,struct dset *pdset)
struct dset *registryDeviceSupportFind(const char *name);

registryDriverSupport

int registryDriverSupportAdd(const char *name,struct drvet *pdrvet);
struct drvet *registryDriverSupportFind(const char *name);

/* The following function is generated by registerRecordDeviceDriver/pl */
int registerRecordDeviceDriver(DBBASE *pdbbase);

registerRecordDeviceDriver.pl

• execute this script using the dbd file created by dbExpand
• compile the resulting C file
• Make the object file part of the xxxLib file

registerRecordDeviceDriver.c

Navigate by Date:

Prev: problems with downloading EPICS Lifang Zheng

Next: Unix sequencer William Lupton

Index: 1994  1995  1996  1997  1998  <1999>  2000  2001  2002  2003  2004  2005  2006  2007  2008  2009  2010  2011  2012  2013  2014  2015  2016  2017  2018  2019  2020  2021  2022  2023  2024 

Navigate by Thread:

Prev: problems with downloading EPICS Lifang Zheng

Next: RE: iocCore port Peregrine McGehee

Index: 1994  1995  1996  1997  1998  <1999>  2000  2001  2002  2003  2004  2005  2006  2007  2008  2009  2010  2011  2012  2013  2014  2015  2016  2017  2018  2019  2020  2021  2022  2023  2024