|
![]() |
Fractal defines a general conceptual model, along with a programming application interface (API) in Java. According to the official documentation, the Fractal component model is "a modular and extensible component model that can be used with various programming languages to design, implement, deploy and reconfigure various systems and applications, from operating systems to middleware platforms and to graphical user interfaces".
There is a reference implementation, called Julia.
We first tried to use Julia to manipulate active objects (the fundamental
entities in ProActive), but we wouldn't have been able to reuse the features of the Proactive
library, because of the architectures of the libraries.
Julia manipulates a base class by modifying the bytecode or adding interception objects to it. On
the other hand, ProActive is based on a meta-object protocol and provides a reference to an active
object through a typed stub. If we wanted to use active objects with Julia, the Julia runtime would
try to manipulate the stub, and not the active object itself. And if trying to force Julia to work
on the same base object than ProActive, the control flow could not traverse both ProActive and
Julia.
Eventually, re-implementing ProActive using Julia could be a solution (a starting point could be the
"protoactive" example of Julia), but this would imply a full refactoring of the library, and
therefore quite a few resources...
More generally speaking, Julia is designed to work with standard objects, but not with the active
objects of ProActive. Some features (see next section) would not be reusable using Julia with
ProActive active objects.
Therefore, we had to go for our own implementation.
This implementation is different from Julia both in its objectives and in the programming technniques. As previously stated, we target Grid and P2P environments. The programming techniques and the architecture of the implementation is described in a following section.
The combination of the Fractal model with the ProActive library leverages the capabilities of both of them.
Distribution is achieved in a transparent manner over the Java RMI protocol thanks to the use of a stub/proxy pattern. Components are manipulated indifferently of their location (local or on a remote JVM).
ProActive provides a deployment framework for creating a distributed component system. Using a configuration file and the concept of virtual nodes, this framework :
A fundamental concept of the ProActive library is this of active objects, where activities can actually be redefined so as to customize their behavior.
Asynchronous method calls with transparent futures is a core feature of ProActive, and it allows concurrent processing. Indeed, suppose a caller invokes a method on a callee. This method returns a result on a component. With synchronous method calls, the flow of execution of the caller is blocked until the result of the method called is received. In the case of intensive computations, this can be relatively long. With asynchronous method calls, the caller gets a future object and will continue its tasks until it really uses the result of the method call. The process is then blocked (it is called wait-by-necessity) until the result has effectively been calculated.