-- --
-- B o d y --
-- --
--- $Revision: 1.1 $ --
--- --
--- Copyright (C) 1992,1993,1994,1995 Free Software Foundation, Inc. --
+-- Copyright (C) 1992-2009, Free Software Foundation, Inc. --
-- --
-- GNAT is free software; you can redistribute it and/or modify it under --
-- terms of the GNU General Public License as published by the Free Soft- --
--- ware Foundation; either version 2, or (at your option) any later ver- --
+-- ware Foundation; either version 3, or (at your option) any later ver- --
-- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
-- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
--- or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License --
--- for more details. You should have received a copy of the GNU General --
--- Public License distributed with GNAT; see file COPYING. If not, write --
--- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
--- MA 02111-1307, USA. --
+-- or FITNESS FOR A PARTICULAR PURPOSE. --
+-- --
+-- As a special exception under Section 7 of GPL version 3, you are granted --
+-- additional permissions described in the GCC Runtime Library Exception, --
+-- version 3.1, as published by the Free Software Foundation. --
-- --
--- As a special exception, if other files instantiate generics from this --
--- unit, or you link this unit with other files to produce an executable, --
--- this unit does not by itself cause the resulting executable to be --
--- covered by the GNU General Public License. This exception does not --
--- however invalidate any other reasons why the executable file might be --
--- covered by the GNU Public License. --
+-- You should have received a copy of the GNU General Public License and --
+-- a copy of the GCC Runtime Library Exception along with this program; --
+-- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
+-- <http://www.gnu.org/licenses/>. --
-- --
-- GNAT was originally developed by the GNAT team at New York University. --
--- It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). --
+-- Extensive contributions were provided by Ada Core Technologies Inc. --
-- --
------------------------------------------------------------------------------
+-- Version for ???
+
with Unchecked_Deallocation;
with Ada.Streams;
package body System.RPC is
+ -- ??? general note: the debugging calls are very heavy, especially
+ -- those that create exception handlers in every procedure. Do we
+ -- really still need all this stuff?
+
use type Ada.Streams.Stream_Element_Count;
use type Ada.Streams.Stream_Element_Offset;
Max_Of_Message_Id : constant := 127;
subtype Message_Id_Type is
- Integer range -Max_Of_Message_Id .. Max_Of_Message_Id;
+ Integer range -Max_Of_Message_Id .. Max_Of_Message_Id;
-- A message id is either a request id or reply id. A message id is
-- provided with a message to a receiving stub which uses the opposite
-- as a reply id. A message id helps to retrieve to which task is
type Message_Length_Per_Request is array (Request_Id_Type)
of Ada.Streams.Stream_Element_Count;
- Header_Size : Ada.Streams.Stream_Element_Count
- := Streams.Get_Integer_Initial_Size +
- Streams.Get_SEC_Initial_Size;
+ Header_Size : Ada.Streams.Stream_Element_Count :=
+ Streams.Get_Integer_Initial_Size +
+ Streams.Get_SEC_Initial_Size;
-- Initial size needed for frequently used header streams
Stream_Error : exception;
-- or when a write procedure is executed on a full stream
Partition_RPC_Receiver : RPC_Receiver;
- -- Cache the RPC_Recevier passed by Establish_RPC_Receiver
+ -- Cache the RPC_Receiver passed by Establish_RPC_Receiver
type Anonymous_Task_Node;
task type Anonymous_Task_Type (Self : Anonymous_Task_Node_Access) is
entry Start
- (Message_Id : in Message_Id_Type;
- Partition : in Partition_ID;
- Params_Size : in Ada.Streams.Stream_Element_Count;
- Result_Size : in Ada.Streams.Stream_Element_Count;
- Protocol : in Garlic.Protocol_Access);
- -- This entry provides an anonymous task a remote call to perform
- -- This task calls for a
- -- Request id is provided to construct the reply id by using
- -- -Request. Partition is used to send the reply message. Params_Size
- -- is the size of the calling stub Params stream. Then, Protocol
- -- (used by the environment task previously) allows to extract the
- -- message following the header (The header is extracted by the
- -- environment task)
+ (Message_Id : Message_Id_Type;
+ Partition : Partition_ID;
+ Params_Size : Ada.Streams.Stream_Element_Count;
+ Result_Size : Ada.Streams.Stream_Element_Count;
+ Protocol : Garlic.Protocol_Access);
+ -- This entry provides an anonymous task a remote call to perform.
+ -- This task calls for a Request id is provided to construct the
+ -- reply id by using -Request. Partition is used to send the reply
+ -- message. Params_Size is the size of the calling stub Params stream.
+ -- Then Protocol (used by the environment task previously) allows
+ -- extraction of the message following the header (The header is
+ -- extracted by the environment task)
+ -- Note: grammar in above is obscure??? needs cleanup
end Anonymous_Task_Type;
type Anonymous_Task_Access is access Anonymous_Task_Type;
- type Anonymous_Task_List is
- record
- Head : Anonymous_Task_Node_Access;
- Tail : Anonymous_Task_Node_Access;
- end record;
-
- type Anonymous_Task_Node is
- record
- Element : Anonymous_Task_Access;
- Next : Anonymous_Task_Node_Access;
- end record;
- -- Types we need to construct a singly linked list of anonymous tasks
- -- This pool is maintained to avoid a task creation each time a RPC
- -- occurs
+ type Anonymous_Task_List is record
+ Head : Anonymous_Task_Node_Access;
+ Tail : Anonymous_Task_Node_Access;
+ end record;
+
+ type Anonymous_Task_Node is record
+ Element : Anonymous_Task_Access;
+ Next : Anonymous_Task_Node_Access;
+ end record;
+ -- Types we need to construct a singly linked list of anonymous tasks.
+ -- This pool is maintained to avoid a task creation each time a RPC occurs.
protected Garbage_Collector is
(Item : in out Anonymous_Task_Node_Access);
-- Anonymous task pool management : queue this task in the pool
-- of inactive anonymous tasks.
+
private
Anonymous_List : Anonymous_Task_Node_Access;
-- When it is resumed, we provide the size of the reply
entry Wake_Up
- (Request : in Request_Id_Type;
- Length : in Ada.Streams.Stream_Element_Count);
- -- To wake up the calling stub when the environnement task has
+ (Request : Request_Id_Type;
+ Length : Ada.Streams.Stream_Element_Count);
+ -- To wake up the calling stub when the environment task has
-- received a reply for this request
end Dispatcher;
-- Debugging package
procedure D
- (Flag : in Debug_Level; Info : in String) renames Debugging.Debug;
+ (Flag : Debug_Level; Info : String) renames Debugging.Debug;
-- Shortcut
------------------------
---------------
procedure Head_Node
- (Index : out Packet_Node_Access;
- Stream : in Params_Stream_Type) is
+ (Index : out Packet_Node_Access;
+ Stream : Params_Stream_Type)
+ is
begin
Index := Stream.Extra.Head;
- exception when others =>
- D (D_Exception, "exception in Head_Node");
- raise;
+
+ exception
+ when others =>
+ D (D_Exception, "exception in Head_Node");
+ raise;
end Head_Node;
---------------
---------------
procedure Tail_Node
- (Index : out Packet_Node_Access;
- Stream : in Params_Stream_Type) is
+ (Index : out Packet_Node_Access;
+ Stream : Params_Stream_Type)
+ is
begin
Index := Stream.Extra.Tail;
- exception when others =>
- D (D_Exception, "exception in Tail_Node");
- raise;
+
+ exception
+ when others =>
+ D (D_Exception, "exception in Tail_Node");
+ raise;
end Tail_Node;
---------------
-- Null_Node --
---------------
- function Null_Node
- (Index : in Packet_Node_Access) return Boolean is
+ function Null_Node (Index : Packet_Node_Access) return Boolean is
begin
return Index = null;
- exception when others =>
- D (D_Exception, "exception in Null_Node");
- raise;
+
+ exception
+ when others =>
+ D (D_Exception, "exception in Null_Node");
+ raise;
end Null_Node;
----------------------
-- Delete_Head_Node --
----------------------
- procedure Delete_Head_Node
- (Stream : in out Params_Stream_Type) is
+ procedure Delete_Head_Node (Stream : in out Params_Stream_Type) is
procedure Free is
new Unchecked_Deallocation
Next_Node : Packet_Node_Access := Stream.Extra.Head.Next;
begin
-
-- Delete head node and free memory usage
Free (Stream.Extra.Head);
Stream.Extra.Tail := null;
end if;
- exception when others =>
- D (D_Exception, "exception in Delete_Head_Node");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Delete_Head_Node");
+ raise;
end Delete_Head_Node;
---------------
-- Next_Node --
---------------
- procedure Next_Node
- (Node : in out Packet_Node_Access) is
+ procedure Next_Node (Node : in out Packet_Node_Access) is
begin
-
-- Node is set to the next node
-- If not possible, Stream_Error is raised
Node := Node.Next;
end if;
- exception when others =>
- D (D_Exception, "exception in Next_Node");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Next_Node");
+ raise;
end Next_Node;
---------------------
-- Append_New_Node --
---------------------
- procedure Append_New_Node
- (Stream : in out Params_Stream_Type) is
+ procedure Append_New_Node (Stream : in out Params_Stream_Type) is
Index : Packet_Node_Access;
- begin
+ begin
-- Set Index to the end of the linked list
Tail_Node (Index, Stream);
Stream.Extra.Tail := Stream.Extra.Head;
else
-
-- The list is not empty : link new node with tail
Stream.Extra.Tail.Next := new Packet_Node;
end if;
- exception when others =>
- D (D_Exception, "exception in Append_New_Node");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Append_New_Node");
+ raise;
end Append_New_Node;
----------
procedure Read
(Stream : in out Params_Stream_Type;
Item : out Ada.Streams.Stream_Element_Array;
- Last : out Ada.Streams.Stream_Element_Offset) renames
- System.RPC.Streams.Read;
+ Last : out Ada.Streams.Stream_Element_Offset)
+ renames System.RPC.Streams.Read;
-----------
-- Write --
procedure Write
(Stream : in out Params_Stream_Type;
- Item : in Ada.Streams.Stream_Element_Array) renames
- System.RPC.Streams.Write;
+ Item : Ada.Streams.Stream_Element_Array)
+ renames System.RPC.Streams.Write;
-----------------------
-- Garbage_Collector --
-- Garbage_Collector.Allocate --
--------------------------------
- procedure Allocate
- (Item : out Anonymous_Task_Node_Access) is
+ procedure Allocate (Item : out Anonymous_Task_Node_Access) is
New_Anonymous_Task_Node : Anonymous_Task_Node_Access;
Anonymous_Task : Anonymous_Task_Access;
- begin
+ begin
-- If the list is empty, allocate a new anonymous task
-- Otherwise, reuse the first queued anonymous task
New_Anonymous_Task_Node.all := (Anonymous_Task, null);
else
-
-- Extract one task from the list
-- Set the Next field to null to avoid possible bugs
Item := New_Anonymous_Task_Node;
- exception when others =>
- D (D_Exception, "exception in Allocate (Anonymous Task)");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Allocate (Anonymous Task)");
+ raise;
end Allocate;
----------------------------------
-- Garbage_Collector.Deallocate --
----------------------------------
- procedure Deallocate
- (Item : in out Anonymous_Task_Node_Access) is
+ procedure Deallocate (Item : in out Anonymous_Task_Node_Access) is
begin
-
-- Enqueue the task in the free list
Item.Next := Anonymous_List;
Anonymous_List := Item;
- exception when others =>
- D (D_Exception, "exception in Deallocate (Anonymous Task)");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Deallocate (Anonymous Task)");
+ raise;
end Deallocate;
end Garbage_Collector;
------------
procedure Do_RPC
- (Partition : in Partition_ID;
+ (Partition : Partition_ID;
Params : access Params_Stream_Type;
- Result : access Params_Stream_Type) is
+ Result : access Params_Stream_Type)
+ is
Protocol : Protocol_Access;
Request : Request_Id_Type;
Header : aliased Params_Stream_Type (Header_Size);
R_Length : Ada.Streams.Stream_Element_Count;
- begin
+ begin
-- Parameters order :
-- Opcode (provided and used by garlic)
-- (1) Size (provided by s-rpc and used by garlic)
declare
New_Result : aliased Params_Stream_Type (R_Length);
begin
-
-- Adjust the Result stream size right now to be able to load
- -- the stream in one receive call. Create a temporary resutl
+ -- the stream in one receive call. Create a temporary result
-- that will be substituted to Do_RPC one
Streams.Allocate (New_Result);
end;
else
-
-- Do RPC locally and first wait for Partition_RPC_Receiver to be
-- set
end if;
- exception when others =>
- D (D_Exception, "exception in Do_RPC");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Do_RPC");
+ raise;
end Do_RPC;
------------
------------
procedure Do_APC
- (Partition : in Partition_ID;
- Params : access Params_Stream_Type) is
+ (Partition : Partition_ID;
+ Params : access Params_Stream_Type)
+ is
Message_Id : Message_Id_Type := 0;
Protocol : Protocol_Access;
Header : aliased Params_Stream_Type (Header_Size);
- begin
+ begin
-- For more informations, see above
-- Request = 0 as we are not waiting for a reply message
-- Result length = 0 as we don't expect a result at all
declare
Result : aliased Params_Stream_Type (0);
begin
-
-- Result is here a dummy parameter
-- No reason to deallocate as it is not allocated at all
end if;
- exception when others =>
- D (D_Exception, "exception in Do_APC");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Do_APC");
+ raise;
end Do_APC;
----------------------------
-- Establish_RPC_Receiver --
----------------------------
- procedure Establish_RPC_Receiver (
- Partition : in Partition_ID;
- Receiver : in RPC_Receiver) is
+ procedure Establish_RPC_Receiver
+ (Partition : Partition_ID;
+ Receiver : RPC_Receiver)
+ is
begin
-
-- Set Partition_RPC_Receiver and allow RPC mechanism
Partition_RPC_Receiver := Receiver;
Partition_Receiver.Set;
D (D_Elaborate, "Partition_Receiver is set");
- exception when others =>
- D (D_Exception, "exception in Establish_RPC_Receiver");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Establish_RPC_Receiver");
+ raise;
end Establish_RPC_Receiver;
----------------
Last_Request : Request_Id_Type := Request_Id_Type'First;
Current_Rqst : Request_Id_Type := Request_Id_Type'First;
Current_Size : Ada.Streams.Stream_Element_Count;
- begin
+ begin
loop
+ -- Three services:
- -- Three services :
- -- New_Request to get an entry in Dispatcher table
- -- Wait_On for Do_RPC calls
- -- Wake_Up called by environment task when a Do_RPC receives
- -- the result of its remote call
+ -- New_Request to get an entry in Dispatcher table
- select
+ -- Wait_On for Do_RPC calls
- accept New_Request
- (Request : out Request_Id_Type) do
+ -- Wake_Up called by environment task when a Do_RPC receives
+ -- the result of its remote call
+
+ select
+ accept New_Request (Request : out Request_Id_Type) do
Request := Last_Request;
-- << TODO >>
- -- Avaibility check
+ -- ??? Availability check
if Last_Request = Request_Id_Type'Last then
Last_Request := Request_Id_Type'First;
end New_Request;
or
-
accept Wake_Up
- (Request : in Request_Id_Type;
- Length : in Ada.Streams.Stream_Element_Count) do
-
+ (Request : Request_Id_Type;
+ Length : Ada.Streams.Stream_Element_Count)
+ do
-- The environment reads the header and has been notified
-- of the reply id and the size of the result message
end Wake_Up;
-- << TODO >>
- -- Must be select with delay for aborted tasks
+ -- ??? Must be select with delay for aborted tasks
select
accept Wait_On (Current_Rqst)
- (Length : out Ada.Streams.Stream_Element_Count) do
+ (Length : out Ada.Streams.Stream_Element_Count)
+ do
Length := Current_Size;
end Wait_On;
or
-
-- To free the Dispatcher when a task is aborted
delay 1.0;
end select;
or
-
terminate;
-
end select;
end loop;
- exception when others =>
- D (D_Exception, "exception in Dispatcher body");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Dispatcher body");
+ raise;
end Dispatcher;
-------------------------
Params_S : Ada.Streams.Stream_Element_Count; -- Params message size
Result_S : Ada.Streams.Stream_Element_Count; -- Result message size
C_Protocol : Protocol_Access; -- Current Protocol
- begin
+ begin
loop
-
-- Get a new RPC to execute
select
accept Start
- (Message_Id : in Message_Id_Type;
- Partition : in Partition_ID;
- Params_Size : in Ada.Streams.Stream_Element_Count;
- Result_Size : in Ada.Streams.Stream_Element_Count;
- Protocol : in Protocol_Access) do
+ (Message_Id : Message_Id_Type;
+ Partition : Partition_ID;
+ Params_Size : Ada.Streams.Stream_Element_Count;
+ Result_Size : Ada.Streams.Stream_Element_Count;
+ Protocol : Protocol_Access)
+ do
C_Message_Id := Message_Id;
C_Partition := Partition;
Params_S := Params_Size;
end select;
declare
- Params : aliased Params_Stream_Type (Params_S);
- Result : aliased Params_Stream_Type (Result_S);
- Header : aliased Params_Stream_Type (Header_Size);
- begin
+ Params : aliased Params_Stream_Type (Params_S);
+ Result : aliased Params_Stream_Type (Result_S);
+ Header : aliased Params_Stream_Type (Header_Size);
+ begin
-- We reconstruct all the client context : Params and Result
-- with the SAME size, then we receive Params from calling stub
(Header'Access,
Streams.Get_Stream_Size (Result'Access));
-
- -- Get a protocol method to comunicate with the remote
+ -- Get a protocol method to communicate with the remote
-- partition and give the message size
D (D_Communication,
(C_Protocol.all,
C_Partition);
Streams.Deallocate (Header);
-
end if;
Streams.Deallocate (Params);
Streams.Deallocate (Result);
-
end;
-- Enqueue into the anonymous task free list : become inactive
end loop;
- exception when others =>
- D (D_Exception, "exception in Anonymous_Task_Type body");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Anonymous_Task_Type body");
+ raise;
end Anonymous_Task_Type;
-----------------
Header : aliased Params_Stream_Type (Header_Size);
Protocol : Protocol_Access;
Anonymous : Anonymous_Task_Node_Access;
- begin
+ begin
-- Wait the Partition_RPC_Receiver to be set
accept Start;
D (D_Elaborate, "Environment task elaborated");
loop
-
-- We receive first a fixed size message : the header
-- Header = Message Id + Message Size
-- protocol to use to communicate with the calling partition
Garlic.Initiate_Receive
- (Partition,
- Message_Size,
- Protocol,
- Garlic.Remote_Call);
+ (Partition,
+ Message_Size,
+ Protocol,
+ Garlic.Remote_Call);
D (D_Communication,
"Environment task - Receive protocol to talk to active partition" &
Partition_ID'Image (Partition));
"Environment task - Receive Header from partition" &
Partition_ID'Image (Partition));
Garlic.Receive
- (Protocol.all,
- Partition,
- Header'Access);
+ (Protocol.all,
+ Partition,
+ Header'Access);
-- Evaluate the remaining size of the message
Dispatcher.Wake_Up (-Message_Id, Result_Size);
else
-
-- The message was send by a calling stub : get an anonymous
-- task to perform the job
Garbage_Collector.Allocate (Anonymous);
-- We subtracted the size of the header from the size of the
- -- global message in order to provide immediatly Params size
+ -- global message in order to provide immediately Params size
Anonymous.Element.Start
(Message_Id,
end loop;
- exception when others =>
- D (D_Exception, "exception in Environment");
- raise;
+ exception
+ when others =>
+ D (D_Exception, "exception in Environment");
+ raise;
end Environnement;
begin
-
-- Set debugging information
Debugging.Set_Environment_Variable ("RPC");
OSDN Git Service
