Real-Time Distributed Middleware

With the increasing scale and complexity of current distributed applications, Object Oriented (OO) software design methodology is gaining popularity in this field. This
is due to the increased flexibility, reusability, and maintainability of object oriented systems. The use of large scale distributed object oriented programming requires seamless
interoperability among heterogeneous client and server objects. The Common Object Request Broker Architecture (CORBA), developed by the Object Management
Group (OMG), is becoming a renowned standard for object-oriented distributed environments. CORBA is a middleware that establishes the relationship between client and
server objects while hiding the implementation and location details of both objects. This simplifies the process of developing more complex and flexible distributed applications and makes the development cycle much shorter.

In order to achieve timely execution of service requests, the client must have a way to express the required timing requirements, and the CORBA system must provide methods for expressing and enforcing timing constraints. The distributed nodes’ operating systems as well as the underlying network must support real-time constraint enforcement. The released RT-CORBA specifications describe the requirements to be provided and managed by the communication infrastructure, OS scheduling mechanism, and ORB end-system to ensure end-to-end predictable behavior. The RT-CORBA specifications mainly target fixed priority real-time systems and provide applications with interfaces to manage their resources, thread assignment, and priorities.

Our main objective is to develop a complete model for scheduling and dispatching hard and soft real-time service requests in a CORBA-based distributed environment. The
model presented consists of two major phases. The off-line system schedulability analysis phase. During this phase, all system’s functional and timing information are aggregated and evaluated for feasibility. The scheduling phase is performed by a central node that is reachable by all the system’s distributed nodes. The second phase is the run-time task execution phase. In this phase, each of the system’s nodes independently executes its local load of tasks in conformance with the global system feasibility. The model uses an agent object at run-time to execute each node’s task dispatching calendar.

An instance of the dispatcher object runs on each node in the system. The dispatcher is responsible for analyzing the node’s local application objects and dispatching run-time tasks according to the system’s timing requirements. In the off-line system analysis phase, the node dispatcher runs as part of the CORBA IDL compiler, or as a preprocessor for it. The dispatcher parses the application objects’ IDL code and timing requirements’ specifications and register them with the central real-time scheduler. At runtime, the node dispatcher runs in the context of two objects, the Dispatcher Event Server and the HRT Server Agent. At run-time, a node’s dispatcher objects are responsible for executing local hard real-time client jobs as well as server jobs generated as a result of external service requests according to the node’s parametric dispatching calendar. The node dispatcher’s components and its role in dispatching hard real-time CORBA service requests are illustrated in the previous figure.