C EXECUTIVE provides the system features you need - interrupt-driven device drivers, real-time clock support, a fully preemptive prioritized task scheduler, and four methods of inter-task coordination: semaphores, events, data queues, and signals. Since it is both ROMable and highly portable, it provides an extremely flexible system component. Only main memory is required for operation, although an optional filesystem is available.
C EXECUTIVE allows multi-tasking applications to execute in a minimum hardware configuration - suitable for low-cost, high-volume products. First delivered in October 1981, current applications of C EXECUTIVE include military avionics, laboratory data acquisition, X-Windows terminals, cardiac monitors, civilian and military radar displays, medical and electronic test PDA products, graphics terminals, laser printer controllers, point-of-sale terminals, GPS receivers, interactive gaming systems, Ethernet gateways, modems, portable military radios, process control and PBX communication systems. Laser printers are a specialty for C EXECUTIVE - over 20 companies use the kernel for laser printers across 7 CPU architectures.
95% of C EXECUTIVE is written in ANSI Standard C for maximum reliability, portability and maintainability - this implementation also provides the most time and space efficient mechanism for making system calls from C, the dominant language for real-time embedded applications. Other systems require extra layers of interface libraries, resulting in run-time system overhead. Critical sections of C EXECUTIVE, including context switching, task scheduling, and interrupt handling, have been implemented in optimized assembly language. This mixture of C and assembly language provides both a natural C programming environment and fast interrupt response and context switching.
C EXECUTIVE supports an optional filesystem. CE-DOSFILE (tm) is available for all microprocessors supported by C EXECUTIVE. CE-DOSFILE is designed for both optimum performance in real-time applications and for PC-DOS media compatibility. Major extensions to the standard DOS filesystem to improve performance include optional contiguous files and configurable caches for each disk device. A RAM disk driver is also included.
CE-DOSFILE maintains complete media compatibility with DOS - using this filesystem and C EXECUTIVE on any CPU architecture, removable media can be read directly by any DOS system. CE-DOSFILE automatically maintains 80X86 byte order within all filesystem structures, regardless of the host CPU byte ordering.
C EXECUTIVE is suited to modern design methods - a major design goal of C EXECUTIVE is to provide a programming environment that both encourages and facilitates the use of data flow design methods. Data flow design is described in Tom De Marco's book, Structured Analysis and System Specification (Yourdon Press). Using this technique, a system is viewed as a set of independent asynchronous processes, each communicating with each other and the external environment via clearly-defined input and output data streams.
C EXECUTIVE provides UNIX-like features - data queues (like UNIX pipes) and standard I/O allow the direct implementation of data flow designs. Data queues are not limited by message size or number of messages, as with traditional "mailboxes". Messages of various sizes can pass through the same data queue, with end-of-message events automatically alerting waiting tasks. Optional time-outs are available on writing or reading.
C EXECUTIVE provides multiple methods of inter-task coordination. Named binary semaphores, events, inter-process data queues, and signals provide for the best mechanism for each design.
C EXECUTIVE provides built-in support for multiple terminals - all standard terminal input/output facilities, including XON/XOFF, are simple configuration options, requiring no user-written code. Any combination of full-duplex and half-duplex devices can be configured.
C EXECUTIVE uses the same system calls for disks, terminals, queues, and sockets - greatly simplifying system design and implementation. Since interprocess communication, inter-processor I/O and physical I/O are carried out using the same system calls, distributed systems can be easily designed and implemented.
C EXECUTIVE includes a comprehensive portable C library - it contains 100 routines for buffered and formatted I/O, memory allocation and string manipulation. The JMI Portable C Library is the equivalent of a normal UNIX portable library, but is ROMable, sharable and reentrant.
C EXECUTIVE requires no special software development tools - it is compiled, assembled and linked using the same tools as are used for the application programs. The recommended development procedure is to use data flow design to produce functionally cohesive modules which can be easily tested on the host development system (UNIX, VMS, Windows, DOS, etc.), then cross compile the modules (if necessary) and link with C EXECUTIVE. The resultant image can then be booted or downloaded, as required.
C EXECUTIVE supports optional TCP/IP communications - CE-TCP(tm) includes both Ethernet and serial interfaces for TCP/IP, and also includes UDP, ARP, ICMP and SLIP. PPP and SNMP are additional options.
C EXECUTIVE supports an optional system debugger - CE-VIEW(tm) allows prototyping on the target in the same manner that the UNIX shell allows multiple modules to communicate via pipes, with I/O redirection. CE-VIEW can display and change the system configuration, issue system calls and assist in system level debugging, all the while staying on the target board. Since C EXECUTIVE provides a common C language programming interface across so many CPU architectures, including the 80386/80486, a standard PC can be used for target prototyping, regardless of the final target processor or board. The functional behavior of the application will be identical on any CPU.
PSX provides a single-user, single-group, subset of POSIX.1, with up to 32,000 processes and/or threads. PSX adds a substantial subset of the POSIX.1 system calls to the basic C EXECUTIVE kernel. Using these calls allows applications to migrate from POSIX-conformant UNIX platforms to board-level systems, or vice versa.
PSX adds the following system calls to C EXECUTIVE:
cfgetispeed get baud rate from termios struct cfgetospeed get baud rate from termios struct cfsetispeed set baud rate in termios struct cfsetospeed set baud rate in termios struct tcdrain send all pending data tcflow send XON/XOFF tcflush clear read and written data tcgetattr get terminal attributes tcsendbreak send a break to a terminal tcsetattr set terminal attributes
asctime ASCII time conversion ctermid get path of controlling terminal getegid get effective group identifier getenv get environment strings geteuid get effective user identifier getgid get real group identifier getgroups get supplementary group identifiers getlogin get user name getpgrp get process group identifier getpid get process id getppid get parent process id getuid get real user identifier gmtime convert calendar time to UTC isatty get yes for a file descriptor that is a terminal localtime convert UTC to broken-down time mktime convert broken-down time to UTC sysconf get system config limits time obtain time in clock interrupt units times get cpu and user time in ticks ttyname get path of a file descriptor that is a terminal tzset set timezone information uname set process group id
access test file for access permissions chdir change CE-DOSFILE current directory chmod change file mode closedir close a directory stream creat create a file fpathconf query configuration limits on file descriptor fstat get file info for file descriptor getcwd get CE-DOSFILE current directory name mkdir make a CE-DOSFILE directory mkfifo create special FIFO file open open a file opendir open a directory stream pathconf query configuration limits on file name readdir read a directory stream rename rename an existing file rewinddir rewind a directory stream rmdir remove a CE-DOSFILE directory stat get file info for named file unlink remove a file utime set file access and modification times
close close a file dup duplicate file descriptor dup2 duplicate file descriptor lseek set file read/write pointer read read characters from a file write write characters to a file
_exit terminate calling process normally alarm wait for SIGALRM wakeup kill send a signal to a process pause Suspend execution indefinitely sched_yield yield to another process of same or higher priority sigaction examine or change signal action sigaddset add a signal to a signal set sigdelset removes a signal from a signal set sigemptyset clear a signal set sigfillset fill a signal set sigismember test a signal set for a particular signal sigpending examine pending signals sigprocmask examine or change signal mask sigsuspend wait for a signal sigwait synchronously accept a signal sleep suspend process execution for a number of seconds wait suspend process execution and place on a wait list waitpid wait for a process to terminate
pthread_attr_destroy destroy thread attributes pthread_attr_getdetachstate get detachstate attribute pthread_attr_getinheritsched get inheritsched attribute pthread_attr_getschedpolicy get schedpolicy attribute pthread_attr_getschedparam get scheduling attribute pthread_attr_getscope get contentionscope attribute pthread_attr_getstacksize get stacksize attribute pthread_attr_getstackaddr get stackaddr attribute pthread_attr_init initialize thread attributes pthread_attr_setdetachstate set detachstate attribute pthread_attr_setinheritsched set inheritsched attribute pthread_attr_setschedpolicy set schedpolicy attribute pthread_attr_setschedparam set scheduling attribute pthread_attr_setscope set contentionscope attribute pthread_attr_setstackaddr set stackaddr attribute pthread_attr_setstacksize set stacksize attribute pthread_cancel cancel execution of a thread pthread_cleanup_pop remove cancellation handler routine pthread_cleanup_push add cancellation handler routine pthread_cond_broadcast unblock all threads pthread_cond_destroy destroy condition variable pthread_cond_init initialize condition variable pthread_cond_signal unblock thread(s) pthread_cond_timedwait block on condition with timeout pthread_cond_wait block on condition variable pthread_condattr_destroy destroy condition variable attributes pthread_condattr_getpshared get process-shared attributes pthread_condattr_init initialize condition variable attributes pthread_condattr_setpshared set process-shared attributes pthread_create thread creation pthread_detach detach a thread pthread_equal compare thread IDs pthread_exit thread termination pthread_getschedparam get scheduling policy pthread_getspecific get key value pthread_join wait for thread termination pthread_key_create thread-specific data key creation pthread_key_delete thread-specific data key deletion pthread_kill send a signal to a thread pthread_mutex_destroy destroy a mutex pthread_mutex_getprioceiling get current priority ceiling pthread_mutex_init initialize a mutex pthread_mutex_lock lock a mutex pthread_mutex_setprioceiling change priority ceiling pthread_mutex_trylock lock a mutex and return pthread_mutex_unlock unlock a mutex pthread_mutexattr_destroy destroy mutex attributes object pthread_mutexattr_getprotocol get current protocol pthread_mutexattr_getprioceiling get current priority ceiling pthread_mutexattr_getpshared get process-shared attribute pthread_mutexattr_init initialize mutex attributes object pthread_mutexattr_setprotocol change protocol pthread_mutexattr_setprioceiling change priority ceiling pthread_mutexattr_setpshared set process-shared attribute pthread_once dynamic package initialization pthread_self get calling thread's ID pthread_setcancelstate set cancelability state pthread_setcanceltype set cancelability type pthread_setschedparam set scheduling policy pthread_setspecific set key value pthread_sigmask manipulate thread's signal mask pthread_testcancel create cancellation point
getgrgid read group database based on group identifier getgrnam read group database based on group name getpwnam read user database based on user name getpwuid read user database based on user identifier
The following system calls provide control of process execution:
chgepri change effective priority of current process chgpri change the priority of another process chkstk determine heap and stack usage createp create a process cycle periodically schedule a process, by process identifier delay temporarily delay process execution deletep delete a process entreg enter a critical region entsig enter a signal critical region ewait suspend process execution and place on event list ewaittm suspend process for event, with timeout ewakeup wake up all processes waiting on a event list exit terminate process execution getepri get process effective priority getpid get process identifier gevent get system event flag kill send a signal to a process lock assign resource (semaphore) to calling process lvreg leave a critical region lvsig leave a signal critical region ncycle periodically schedule a process, by name nstart schedule a process to run, by name ntopid convert process name to process identifier onexit call function on process exit pidton convert process identifier to process name profile obtain performance profile information prterr print error description pstart schedule a process to run, by process identifier rawtime obtain time in clock interrupt units resume resume execution of suspended process sbreak set system break pointer setil set interrupt level sevent set system event flag suspend suspend execution of process syssleep suspend process execution for a time interval unlock release resource (semaphore) from calling process wlock wait and assign resource (semaphore) wlocktm wait and assign resource (semaphore), with timeout
close close a queue create create (and open) a queue devcnt get queue buffer character count devmsg get queue buffer message count gdev get queue characteristics gdevno get device number for open file ioctl perform I/O control function on queue open open a queue opendv open a queue by number read read data from a queue readtm read data from a queue with timeout sdev set queue characteristics select synchronous I/O multiplexing write write data to a queue writeqhd write data to head of a queue writetm write data to a queue with timeout
The standard UNIX-style I/O facilities are provided for C programs; each program's standard input, standard output and standard error output may be individually configured for any terminal, data queue, the system null device or any user-added device. Terminals may be reconfigured at run-time to change various parameters.
The following system calls allow access to and control of terminals:
close close a terminal create create (and open) a terminal devcnt get terminal input buffer character count devmsg get terminal input buffer message count gdev get terminal characteristics gdevno get device number for open file ioctl perform I/O control function on terminal open open a terminal opendv open a terminal by device number read read data from a terminal readtm read data from a terminal with timeout sdev set terminal characteristics select synchronous I/O multiplexing write write data to a terminal writetm write data to a terminal with timeout
The initial CE-COMM offering is CE-TCP, which supports TCP, IP, ARP, ICMP, UDP, and SLIP. PPP is also available as an extra option. Device drivers are provided for a variety of devices (see below).
The software was derived from the official NET II distribution of the TCP/IP code. A new Socket Interface was developed to allow user programs access to the socket system calls. An Operating System Interface was also developed specially for C EXECUTIVE. This layer provides the linkage between TCP/IP and the C EXECUTIVE system calls and device drivers.
CE-TCP can be added as a modular extension to existing C EXECUTIVE applications. A simple entry in the existing Device Configuration Table is made for the TCP/IP protocol driver, and also for each physical device driver. Multiple drivers can be configured on the same CPU, including both Ethernet and multiple serial lines. Loopback is also supported.
CE-TCP is highly portable. Porting to a new system architecture requires at least a serial driver (a slightly modified version of a standard C EXECUTIVE serial device driver) or an Ethernet driver. All other code is machine-independent.
CE-SNMP is the second offering under CE-COMM. This option provides the Simple Network Management Protocol, a standard protocol used for communication of management status information. CE-SNMP includes both client and server software, and a Management Information Base (MIB).
Supported Hardware - Ethernet device drivers are available for SMC 8003/8013 (Elite 16, Combo 16), SMC 91C92, Intel 82596, AMD 7990 LANCE, and National Semiconductor DP83932B Sonic. A SLIP/PPP driver is available for the 8250 (and compatible) DUART.
CE-DOSFILE provides a disk filesystem for real-time applications, with fast random access to contiguous files and configurable caches for in-memory directories and data blocks. For the 80X86 family version, a utility program is included to allow CE-DOSFILE to co-reside with the DOS filesystem on PCs and compatibles, or alternatively to use the same DOS filesystem on the hard disk.
CE-DOSFILE provides complete compatibility with standard media, while executing on any CPU architecture under C EXECUTIVE. CE-DOSFILE automatically converts the byte order of all fields within filesystem structures to and from native CPU byte order. DOS diskettes can be created, read and written on-line, using standard C language calls, on any CPU architecture supported by C EXECUTIVE.
A memory driver is included to provide a-high speed RAM disk. Also a disk can be accessed directly using raw mode, bypassing CE-DOSFILE completely.
The following system calls provide access to and control of disks and the filesystem:
chdir change current working directory close close a file create create (and open) a file getcwd get current working directory ioctl perform I/O control function on disk lseek set file read/write pointer mkdir make directory mkfss make file subsystem open open a file opendv open a disk by device number read read data from a file remove remove a file rename change the name of a file rmdir remove a directory sync synchronize filesystem write write data to a file
The cache is automatically used during read and write operations when transferring single integral blocks or partial blocks. When two or more consecutive blocks are transferred, the data bypasses the cache and is transferred directly between memory and the device.
Drivers are supplied for standard floppy and hard disk systems. A memory device driver is included, allowing a portion of main memory to be used as a high speed disk. All drivers are supplied in C source code in both binary and source product packages. A prototype disk driver is supplied with a tutorial on writing new drivers.
The external media format is completely described by DOS and its associated documentation. The one extension to DOS capability is CE-DOSFILE's ability to create contiguous files on request. Although DOS may happen to create contiguous files, there is no way specifically to request a contiguous file. Any contiguous file created by CE-DOSFILE, however, can be read by DOS.
The JMI Portable C Library has been specifically designed for implementing ROMable systems, sharing functions among several processes, and restarting memory-resident systems without reloading.
The JMI Portable C Library contains the following functions:
abs find absolute value alloc allocate memory from heap atof convert ASCII string to floating point atoi convert ASCII string to integer atol convert ASCII string to long btod convert ASCII buffer to double btoi convert ASCII buffer to integer btol convert ASCII buffer to long btos convert ASCII buffer to short calloc allocate and clear heap space cmpbuf compare two buffers for equality cmpstr compare two strings for equality cpybuf copy one buffer to another cpystr copy multiple strings decode convert arguments to text under format control dtoe convert double to buffer in exponential format dtof convert double to buffer in fixed-point format [dumflp] dummy floating point conversion routines encode convert text to internal form under format control errfmt output arguments formatted to error file error output error message and exit fclose close a stream or FIO and flush output fcreate create a file and initialize FIO structure fflush flush a buffered output stream fgetc get a character from buffered input stream fgets get a text line from buffered input stream fill fill buffer with character finit initialize FIO structure fopen open a stream or FIO fprintf output formatted arguments to a stream fputc put a character to buffered output stream fputs put a text line to buffered output stream fread read full size free free allocated space in the heap frelst free list of allocated blocks fscanf input from a stream under format control getc get a character from a stream or FIO buffer getch get a character from stdin FIO buffer getchar get a character from stdin stream getf read formatted nput from FIO buffer getfmt read formatted input from stdin FIO buffer getl get a text line from FIO buffer getlin get a text line from stdin FIO buffer gtc get a character from FIO buffer inbuf find first character from set in buffer instr find first character from set in string isalpha test for alphabetic character isdigit test for digit islower test for lowercase character isspace test for space, tab, or newline isupper test for uppercase character iswhite test for whitespace character itoa convert integer to ASCII string itob convert integer to buffer in any base lenstr find the length of a string lower convert characters in buffer to lowercase ltob convert long to buffer in any base malloc allocate memory from heap max test for maximum min test for minimum nalloc allocate memory from heap notbuf find first character in buffer not in set notstr find first character in string not in set ordbuf compare two buffers for lexical order prefix test if one string is the prefix of another printf format arguments to stdout stream ptc put a character to FIO buffer putc put a character to a stream or FIO buffer putch put a character to stdout FIO buffer putchar put a character to stdout stream putf output arguments formatted to FIO buffer putfmt output arguments formatted to stdout FIO buffer putl put a text line to FIO buffer putlin put a text line to stdout FIO buffer putstr output one or more strings remark output non-fatal error message scanf input from stdin stream under format control scnbuf scan buffer for character scnstr scan string for character sprintf convert arguments to text under format control squeeze delete specified character from buffer sscanf convert text to internal form under format control stdin standard input stream stdout standard output stream stob convert short to buffer in any base strcat concatenate two strings strcmp compare strings algebraically strcpy copy one string to another strlen find the length of a string subbuf find substring in a buffer substr find substring in a string tolower convert character to lowercase toupper convert character to uppercase ungetc put character back into input stream ungetch put character back into stdin stream upper convert characters in buffer to uppercase
CE-VIEW is installed as a normal process, typically at the highest priority and can run concurrently with other application processes (on-line) or stand-alone (off-line). It is supplied in source form to provide maximum flexibility in debugging. CE-VIEW will accept a variety of commands which allow a user to perform the following categories of operations:
cm change memory cq display processes on clock queue cr change terminal CRLF mode dc display terminal or queue configuration de change delay before a process is scheduled dm display memory dp display terminal or queue parameters dq display queue wait lists ds display terminal or queue status ea change terminal ERASE mode ec change terminal ECHO mode er change stderr for a process es change the erase character for a terminal et change the ETXT (end-of-text) character for a terminal or queue ex change terminal or queue ETXT mode fd display file descriptors (open files) for a process fo set the default data/address I/O format (hex, octal, etc) he (help) show CE-VIEW commands and brief description in change stdin for a process ix change terminal IXOFF mode ki change the KILL character for a terminal kl change terminal KILL mode lk lock a resource mc display terminal or queue message and character count nc periodically schedule a process (ncycle) ns start a process (nstart) nt change terminal NTABS mode ou change stdout for a process pa change the parameter passed to a process pe change the scheduling period for a process pf display profiling statistics pr change a process priority ps display process status pt display user process table ra change terminal RAW mode rb reboot (restart the C EXECUTIVE) rc display resource coordination information si change the size of a terminal input buffer or queue buffer so change the size of a terminal output buffer ss change the stack size for a process st change the start flag for a process uc display user configuration ul unlock a resource tq change the timeslice quantum
CE-MTDPPC is an extension to SingleStep for PowerPC from Software Development Systems, USA. (not to be confused with JMI's distributor in India of similar name!)
CE-MTD68K is an extension to SDS's SingleStep for 68XXX.
CE-MTDCF is an extension to SDS's SingleStep for ColdFire.
CE-MACRO386 is an extension to Concurrent Sciences's Soft-Scope for 386/486/Pentium/386EX.
In addition to adding task awareness to each standard debugger, JMI's kernel-aware products also add C EXECUTIVE specific commands, including display of system performance and use of stack and heap. This combines the functions of the standard debugger, plus kernel awareness, with some of the features found in CE-VIEW, all in a common user interface.
The C EXECUTIVE specific commands include the following:
8086/80286, 80186/Am186EM (real mode); 80386/486/Pentium, Am386EM, 80386EX, Am486, Am586, AMD K6 (protected mode); Motorola 68000 through 68060, 683xx; Motorola ColdFire; Intel i960 (80960), i860; AMD 29000 through 29240; PowerPC(403GA, 603, 860/821/823); R3000, R4000, R4200, R4300, R4600; ARM7, ARM7TDMI(Thumb), StrongARM; SH7000; PA-RISC; Sun SPARC; NEC V810/830; Toshiba R3900; Zilog Z80; TI TMS320C6000, TMS320C30/31 and TMS34020; INMOS transputer T212, T222, T400, T425, T800, T801, T805.
Release Target CPU C Compiler Required for Binary Package 3.3 TMS320C6000 TI Code Composer Studio 1.0 3.3 ARM7/StrongARM ARM SDT 2.50, ARM Developer Suite 1.0 3.3 ARM7TDMI(Thumb) ARM SDT 2.50 3.3 80386/486/Pentium/386EX PM Watcom C 11.0, CSi-Link 2.13 3.3 PowerPC Diab Data D-CC 4.2b 3.3 i960 Intel iC-960 , R6.0 3.3 MC68000/68010 Software Development Systems Cross Code C 7.4 3.3 MC68020/30/40/60 Software Development Systems Cross Code C 7.4 3.3 MC68332/360 Software Development Systems Cross Code C 7.4 3.2 ColdFire Diab Data D-CC 4.1a 3.2 80186/88 H-P A.04.00 3.2 TMS320C3x TI TMS320 C Compiler, 4.70 3.2 NEC V810/830 Green Hills V810 Cross Compiler 1.8.8 3.2 R3000 Green Hills C-MIPS 1.8.8 3.2 R4000 Green Hills C-MIPS 1.8.8 3.1 R3000 Cygnus Solutions GNU C 95q3 3.1 R4000 Cygnus Solutions GNU C 95q3 3.1 Am29000 AMD High C 29K 3.3.0. 2.5 SH7000 GNU C, Cygnus Solutions 2.5.90 2.5 PA-RISC HP-UX Native Compiler 9.03 2.5 R3900 Green Hills 1.8.7 2.5 R3000 MIPS ANSI C 3.11 2.5 MC68000/68010 Mentor Graphics' Microtec Division 4.3D 2.5 MC68020/030/040 Mentor Graphics' Microtec Division 4.3D 2.5 MC68332 Mentor Graphics' Microtec Division 4.3D 2.5 Transputer INMOS ANSI C Toolset D7314 2.4A 8086/80286 Microsoft C Optimizing Compiler, 6.00A MASM 6.00, LIB 3.18, LINK 5.13 SPARC Special order - source package only i860 Special order - source package only TMS34020 Special order - source package only 8080/8085/Z80 Special order - source package only NS Series 32000 Special order - source package only Motorola 6809 Special order - source package only
NOTE: All C EXECUTIVE device drivers, including interrupt service routines,
are written in ANSI C. Each driver is about 49% dependent on C EXECUTIVE,
about 49% dependent on the specific device, and only about 2% dependent
on the CPU or board. Thus any of the 100+ device drivers can be moved easily
from one CPU to another.
The development copy of C EXECUTIVE is supplied under a pre-signed license agreement. Licenses for source and OEM use are also available.
To submit a product inquiry form to the corporate sales office click here.
![[JMI Homepage]](home.jpg)