Architecture
Future Software Architecture Architecture for Portability Release 3.0.0.0 (FSAP) is a proprietary framework used by all Aricent products to ensure a high level of portability. FSAP is a framework that comprises:
1) A broad set of guidelines that standardise how to:
 a) design and implement protocol code
b) design and implement interfaces between protocol components
c) design and implement the management interface for protocol components
2) A set of libraries that provide a generic interface to protocol components with respect to OS facilities, buffer management and timer management.
The libraries isolate the environment specific portions of the source code from the core protocol components for portability. FSAP2 conformant software lends itself to minimal porting effort when migrating from one Operating System to another.
FSAP defines a clear set of functionality that should be isolated for portability:
FSAP2 supports a set of generic, modular, lightweight APIs, meant for developers writing cross-platform network protocol software. It is written in ANSI-C and has been built and successfully tested on popular host and target Operating Systems.
FSAP allows easy tailoring to multiple hardware and software architecture. FSAP provides guidelines for the implementation of the software on single-tasking as well as multi-tasking environments. It specifies a framework for implementation according to the processor configuration.
In many cases, software modules have an option for supporting multiple incarnations without the need to replicate the code. FSAP provides scalability without the overhead of multiple instances.
The target dependent components of FSAP-- OSIX (OS Interfaces eXtensions), SRM (Systems Resources Management ) and UTL (UTilities Library ) -- have been organized and grouped in a modular fashion and interact with each other through well-defined service interfaces.
OSIX
The OS Interfaces eXtensions component has evolved after a study of various existing RTOSs and is designed to support any target OS with minimum modifications. OSIX supports a minimal API set that prevents developers from making undue assumptions about the target environment. OSIX APIs provide support for Tasks, Queues, Semaphores and Events.
OSIX features include:
- Multiple task priorities, support for pre-emption and time-slicing.
- IPC using Queues, Semaphores and Events.
- Support for normal and urgent messages.
- Name-based resource identification
SRM
The Systems Resources Management module comprises the memory management buffer management and timer library modules
Memory Management
- Support for memory blocks of heterogeneous sizes.
- Support for memory chunks in discontiguous memory areas.
Buffer Management
SRM's target independent, buffer management library provides the requisite features for layered protocol software.
- Support for buffers of different sizes.
- Facilitates zero-copy architecture.
- Allows for prepending, appending, fragmenting and duplication of messages.
Timer Management
SRM comes with an efficient timer management library, with the following features.
- Support for multiple timer lists -- to support timers of different granularity.
- Timeout indication through callback or event. The callback mechanism facilitates unit testing of protocol modules.
- Display of active timers.
UTL
The UTilities Library consists of commonly used, miscellaneous functions required by software modules. It provides support for the following:
- Linked Lists
- Hash Tables
- Tracing
- Message Dumping
Debugging Support: FSAP2 brings in a disciplined approach to introducing debug statements in the source code. The current debug level at any instant of time is modifiable at run-time. Logs can be directed to the console or to a file depending on user choice.
Summary: FSAP2 brings unmatched flexibility and portability to Future Software Source Code products. Products can be easily tailored for multiple hardware and software architectures with minimal effort.
Interface Procedures
Interface procedures are clearly defined. These will be the routines to be changed during porting.
Performance
The software modules have been tuned for performance. The FSAP architecture defines the structure of the buffers to minimize copying whenever additional headers are added to the data due to the layering scheme.
Modules and Tasks
A module is a functional entity of the software that may be split into multiple tasks. A task is a thread of execution with its own environment. A module is split into multiple tasks if there are independent functions that need to be performed.
Network Management
All products are fully SNMP manageable. FSAP standardises the network management interface for the protocol stacks. The protocol stacks provide open APIs that can be called from any management layer - SNMP, CLI, etc. The interface is designed such that network management need not disrupt target operation.
Deliverables:
- Source Code written in ANSI C
- User Guides for all FSAP components
- FSAP Customization Guide
- Free 90-day support by phone, fax or e-mail.
|
