Many computational problems require a massive amount of processing power in order to be solved in a reasonable amount of time. It is more cost efficient and scalable to implement such applications on a loosely coupled network of workstations rather than on a multiprocessor supercomputer. However, managing the distributed resources on the network when building the application can be difficult. Also, because the state of the network of workstations changes dynamically while the application is executing, the speedup over the application's single processor counterpart is often less than what the developer expects.
In order to build parallel applications for which performance does not degrade as the state of the underlying system changes, We are implementing a Reactive Objects Framework on top of the UNIFY distributed shared memory operating system. UNIFY eases the work of writing the parallel application and the Reactive Objects Framework will provide means for the application to adapt to dynamic changes in the system while the application is running. With this Reactive Objects Framework, we intend to build a library of Reactive Objects which developers can 'plug into' applications to create their reactive systems.
The primary components of the Reactive Objects Framework are the Monitoring Layer and the Reactive Objects Layer.
The Monitoring Layer's tasks are to compile and condense information about the underlying system, and to present this information to the Reactive Object Layer. The Monitoring Layer consists of two sub-layers, the Distributed State Monitoring Layer and the Local State Monitoring Layer.
The Distributed State Monitoring Layer monitors the state of the distributed system and notifies the Reactive Object Layer when the state of the this system changes. The Reactive Object Layer determines the state changes about which it should be notified by registering predicates with the Distributed State Layer. Predicates can be global, nonlocal, or local. Global predicates specify overall system state. Nonlocal predicates specify system state spanning more than one machine. Local predicates are passed down to the Local State Layer and specify state for the local machine.
A predicate 'fires' when it evaluates to true, and when this occurs, a notification in passed up to the Reactive Objects Layer.
The Local State Layer monitors the state of the local machine. It Accepts predicates passed down by the Distributed State Layer, and notifies the Distributed State Layer if any of the registered predicates evaluate to true.
The Reactive Object Layer consists of a collection of Reactive Objects which register predicates and can adapt to changes in the system state when notified by the Monitoring Layer. To support adaptation, a Reactive Object contains one or more adjustable, distributed data objects , a policy component and an adaptive algorithm , or set of algorithms. The adjustable data object is a storage abstraction which knows how to distribute itself across nodes in the distributed system. It provides methods which, when invoked, can change how it is distributed across these nodes. The policy component, which is responsible for controlling the adaptation of the object, registers predicates with, and can respond to notifications from the distributed state layer by modifying the adjustable data structures and adaptive algorithms. The adaptive algorithm controls the set of computations which can be performed upon the Reactive Object.
For more information about the Reactive Object Framework, please consult the following paper: