T-Kernel is a real-time operating system for embedded system use, applicable to a wide range of systems large and small. It is aimed at enhancing portability of software such as device drivers and middleware.
The T-Kernel specification is designed to be applicable even to large-scale systems. So there are features unnecessary for small systems. The approach of defining subsets has the disadvantage of hampering portability of device drivers, middleware and other software. Functional requirements also vary widely from one target system to another, making it difficult to settle on workable subset specifications.
The T-Kernel specification does not adopt a layer division or other subset approach. In principle, all the T-Kernel implementations must implement the specification in their entirety. However, the simple dummy implementation can be applied to those functions that are not required in the target systems.
A “Simple dummy implementation” means one that does not provide the entire range of specified functions but does not behave abnormally (return error, etc.) if a non-implemented function is called. It is important to provide an environment on which a middleware developed for a large system can run without modification. For example, a system that does not use an MMU (Memory Management Unit) can implement the T-Kernel/SM LockSpace() as follows:
#define LockSpace(addr, len) ( E_OK )
The absence of an MMU does not, however, permits the implementor not to implement LockSpace() or to return the error code E_NOSPT.
At the same time, when middleware is designed or developed, leaving out LockSpace() from an implementation because the target system does not use an MMU would prevent the middleware from supporting a system that does use an MMU.
Providing users with the means for removing or skipping unnecessary functions is also allowed. However, the resulting T-Kernel is judged as modified T-Kernel.
Middleware vendors must note the following points:
Middleware must be designed to meet all the T-Kernel requirements. It is important, in other words, that middleware developed for large-scale systems can run without problem on other systems.
Providing users with the means for removing or skipping unnecessary functions is allowed.