GridRPC in distributed computing, is Remote Procedure Call over a grid. This paradigm has been proposed by the GridRPC working group of the Open Grid Forum (OGF), and an API has been defined in order for clients to access remote servers as simply as a function call. It is used among numerous Grid middleware for its simplicity of implementation, and has been standardized by the OGF in 2007. For interoperability reasons between the different existing middleware, the API has been followed by a document describing good use and behavior of the different GridRPC API implementations. Works have then been conducted on the GridRPC Data Management, which has been standardized in 2011.
Scope
The scope of this standard is to offer recommendations for the implementation of middleware. It deals with the following topics:
Definition of a specific data structure for arguments in GridRPC middleware. Definition of the data type to be used in conjunction with the arguments' data structure. Definition of the creation, destruction, lifetime and copy semantics for the arguments' data structure. Definition of possible introspection capabilities for call arguments and attributes of remote functions (e.g. data types, counts). Definition of mechanisms for handling persistent data, e.g., definition and use of a concept such as "data handles" (which might be the same as or similar to a grpc_data_t data type). This may also involve concepts such as lazy copy semantics, and data leases or time-outs. Definition of API mechanisms to enable workflow management. Evaluate the compatibility and interoperability with other systems, e.g., Web Services Resource Framework. Desirable Properties—the Proposed Recommendation will not necessarily specify any properties, such as thread safety, security, and fault tolerance, but it should not be incompatible with any such useful properties. Demonstrate implementability of all parts of the API. Demonstrate and evaluate at least two implementations of the complete GridRPC middleware recommendation.
Context
Among existing middleware and application programming approaches, one simple, powerful, and flexible approach consists in using servers available in different administrative domains through the classical client-server or Remote Procedure Call (RPC) paradigm. Network Enabled Servers (NES) implement this model, which is also called GridRPC. Clients submit computation requests to a resource broker whose goal is to find a server available on the Grid. Scheduling is frequently applied to balance the work among the servers and a list of available servers is sent back to the client; the client is then able to send the data and the request to one of the suggested servers to solve its problem. Thanks to the growth of network bandwidth and the reduction of network latency, small computation requests can now be sent to servers available on the Grid. To make effective use of today's scalable resource platforms, it is important to ensure scalability in the middleware layers as well. This service-oriented approach is not new.
Several research projects have targeted this paradigm in the past. The main middleware implementing the API are DIET, NetSolve/GridSolve, Ninf, but some other environments use it like the SAGA interface from the OGF, and without the standardized API calls, like OmmiRPC, XtremWeb. The RPC model over the internet has also been used for several applications. Transparently through the Internet, large optimization problems can be solved using different approaches by simply filling a web page for remote image processing computations, the use of mathematical libraries or studies on heuristics and resolution methods for sparse linear algebra like GridTLSE. This approach of providing computation services through the Internet is also highly close to the Service Oriented Computing (SOA) paradigm, and is the core of the Cloud computing.
Standardization and GridRPC API presentation
One simple, yet effective, mean to execute jobs on a computing grid is
to use a GridRPC middleware, which relies on the GridRPC
paradigm. For each request, the GridRPC middleware manages the management of the
submission, of the input and output data, of the execution of the job
on the remote resource, etc. To make available a service, a programmer
must implement two codes: a client, where data are defined and which
is run by the user when requesting the service, and a server, which
contains the implementation of the service which is executed on the
remote resource.