iocCore port

[Marty Kraimer <mrk@aps.anl.gov>]

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

iocCore includes the following components of epics base:

• 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

The following Operating System Independent libraries replace vxWorks specific
libraries.

• 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.

In addition the following new base components are provided

• cantProceed

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

replaces symFindByName

Registry

It is not possible to expect every environment to supply an environment
that makes it easy to implement  vxWorks symFindByName. Instead a
facility to register and find pointers to functions and structures is provided.
This leaves the problem of registering everything currently located via
calls to symFindByName. The following solves the problem:

• 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 :-)

The build environment is different. The principal features are:

• 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

This will go away.

• 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

If the target is not for vxWorks, the vxWorks target shell is not available.
IocInit, dbLoadRecords, etc  must be  called directly by main
or the equivalent. The "nice" vxWorks debugging environment is not available
although a nicer one using xgdb may be available.

How do we run dbpr, dbgf, etc?

Interrupt Level

The vxWorks intLock/intUnlock routines are an essential part of base. For
example any code, including interrupt routines, can call callbackRequest.
osiInterrupt is provided to solve this problem. For operating systems like
vxWorks, in which everything runs in a shared memory, multithreaded kernel
environment, an osi specific version must be provided. For other operating
systems, e.g. winxx, Unix, Linux, a generic version is provided. The only
restriction is that kernel code MUST not call any of the osi routines.

Status Of Port

The following has been done:

• 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

This section contains prototype definitions of what needs to be implemented
for each port of iocCore.

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 vxWorks specific version is provided that provides exactly the same semantics
as 3.13.

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 vxWorks version is provided that calls symFindByName. It is called by
the registry if a name is not found in the registry itself.

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 vxWorks specific version is provided. It maps directly to intLib calls.

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 vxWorks specific version is provided that maps directly to rngLib calls.

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

For POSIX

• 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.

For vxWorks

• 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 priorities are assigned a value from 0 to 99. A higher value means
higher priority

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 vxWorks osiThread is implement via calls to taskLib

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

• osiSem
• pthread and POSIX.4
• Special code

Thread is not implemented for a single threaded environment.

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);
A vxWorks version is provided that maps directly into mwdLib calls.

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);
cantProceed prints error message and then

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

callocMustSucceed is like calloc except that it does not return if storage
is not available. A lot of iocCore is initialized by iocInit. If memory
allocation fails during iocInit it is not possible to recover. mallocMustSucceed
is like malloc except that it does not return if storage is not available.

REGISTRY

iocCore currently uses symFindByName to dynamically bind the following:

• 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.

This only the first two items need a solution. The existing implementation
solves the first problem. No solution has been provided for the subroutine
records but it will not be hard implement.

Overview

The basic idea is to provide a registration facility. Any storage meant
to be "globally" accessable must be registered before it can be accessed
by other code.

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);
This is the code which does the work. Each different set of things to register
must have it's own unique ID. Everything to be registered is stored in
the same gpHash table.

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);
Some features:

• 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);
This provides access to the device support entry table.

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);
This provides access to the driver support entry table.

registerRecordDeviceDriver.pl

This is the perl script which creates a c source file that registers record/device/driver
support. Make rules are provided that

• 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

A version of this is provided for vxWorks. This version makes it unnecessary
to use registerRecordDeviceDriver.pl or register other external names.
Thus for vxWorks everything can work almost exactly like it did in release
3.13.x