Contents   Index   Search   Previous   Next

E.2.3 Remote Call Interface Library Units

   [A remote call interface library unit can be used as an interface for remote procedure calls (RPCs) (or remote function calls) between active partitions.]

Language Design Principles

The restrictions governing a remote call interface library unit are intended to ensure that the values of the actual parameters in a remote call can be meaningfully sent between two active partitions.


{categorization pragma (Remote_Call_Interface) [partial]} {pragma, categorization (Remote_Call_Interface) [partial]} The form of a pragma Remote_Call_Interface is as follows:
  pragma Remote_Call_Interface[(library_unit_name)];
The form of a pragma All_Calls_Remote is as follows:
  pragma All_Calls_Remote[(library_unit_name)];
{library unit pragma (All_Calls_Remote) [partial]} {pragma, library unit (All_Calls_Remote) [partial]} A pragma All_Calls_Remote is a library unit pragma.

Legality Rules

     {8652/0078} {remote call interface} {RCI (library unit)} {RCI (package)} {RCI (generic)} {remote subprogram} A remote call interface (RCI) is a library unit to which the pragma Remote_Call_Interface applies. A subprogram declared in the visible part of such a library unit, or declared by such a library unit, is called a remote subprogram.
   The declaration of an RCI library unit shall be preelaborable (see 10.2.1), and shall depend semantically only upon declared pure, shared passive, remote types, or other remote call interface library units.
     {8652/0078} In addition, the following restrictions apply to the visible part of an RCI library unit:
Reason: {8652/0078} Remote call interface units packages do not provide remote data access. A shared passive package has to be used for that.
Reason: We disallow the declaration of task and protected types, since calling an entry or a protected subprogram implicitly passes an object of a limited type (the target task or protected object). We disallow other limited types since we require that such types have user-defined Read and Write attributes, but we certainly don't want the Read and Write attributes themselves to involve remote calls (thereby defeating their purpose of marshalling the value for remote calls).
Reason: This is disallowed because the body of the nested generic would presumably have access to data inside the body of the RCI package, and if instantiated in a different partition, remote data access might result, which is not supported.
Reason: No restrictions apply to the private part of an RCI package, and since a public child can ``see'' the private part of its parent, such a child must itself have a Remote_Call_Interface pragma, and be assigned to the same partition (see below).
Discussion: We considered making the public child of an RCI package implicitly RCI, but it seemed better to require an explicit pragma to avoid any confusion.
Note that there is no need for a private child to be an RCI package, since it can only be seen from the body of its parent or its siblings, all of which are required to be in the same active partition.
    If a pragma All_Calls_Remote applies to a library unit, the library unit shall be a remote call interface.

Post-Compilation Rules

    A remote call interface library unit shall be assigned to at most one partition of a given program. A remote call interface library unit whose parent is also an RCI library unit shall be assigned only to the same partition as its parent.
Implementation Note: {8652/0078} The declaration of an RCI unit package, with a calling-stub body, is automatically included in all active partitions with compilation units that depend on it. However the whole RCI library unit, including its (non-stub) body, will only be in one of the active partitions.
    {compilation units needed (remote call interface) [partial]} {needed (remote call interface) [partial]} {notwithstanding} Notwithstanding the rule given in 10.2, a compilation unit in a given partition that semantically depends on the declaration of an RCI library unit, needs (in the sense of 10.2) only the declaration of the RCI library unit, not the body, to be included in that same partition. [Therefore, the body of an RCI library unit is included only in the partition to which the RCI library unit is explicitly assigned.]

Implementation Requirements

      {8652/0078} If a pragma All_Calls_Remote applies to a given RCI library unit package, then the implementation shall route any call to a subprogram of the RCI unit package from outside the declarative region of the unit package through the Partition Communication Subsystem (PCS); see E.5. Calls to such subprograms from within the declarative region of the unit package are defined to be local and shall not go through the PCS.
Discussion: {8652/0078} Without this pragma, it is presumed that most implementations will make direct calls if the call originates in the same partition as that of the RCI unit package. With this pragma, all calls from outside the subsystem rooted at the RCI unit package are treated like calls from outside the partition, ensuring that the PCS is involved in all such calls (for debugging, redundancy, etc.).
Reason: There is no point to force local calls (or calls from children) to go through the PCS, since on the target system, these calls are always local, and all the units are in the same active partition.

Implementation Permissions

    An implementation need not support the Remote_Call_Interface pragma nor the All_Calls_Remote pragma. [Explicit message-based communication between active partitions can be supported as an alternative to RPC.]
Ramification: Of course, it is pointless to support the All_Calls_Remote pragma if the Remote_Call_Interface pragma (or some approximate equivalent) is not supported.

Contents   Index   Search   Previous   Next   Legal