UNIT – II

MESSAGE PASSING AND RPC

Essay Questions
1. What is meant by message passing and explain in detail?
Inter process communication (IPC) basically requires information sharing among two or
more processes. Two basic methods for information sharing are as follows:
(a) Original sharing, or shared-data approach;
(b) Copy sharing, or message-passing approach.

P Shared common P
1
memory area 2
(a)

P P
1 2
(b)

Fig: Message Passing

Two basic Inter Process Communication Paradigms: the shared data approach and message
passing approach.
In the shared-data approach the information to be shared is placed in a common memory
area that is accessible to all processes involved in an IPC.
In the message-passing approach, the information to be shared is physically copied from the
sender process’s space to the address space of all the receiver processes and this is done by
transmitting the data to be copied in the form of messages (message is a block of information).
A Message-Passing System is a subsystem of distributed operating system that provides a
set of message-based IPC protocols and does so by shielding the details of complex network
protocols and multiple heterogeneous platforms from programmers. It enables processes to
communicate by exchanging messages and allows programs to be written by using simple
communication primitives, such as send and receive.

2. Explain the features of message passing systems?

(a) Simplicity: A message passing system should be simple and easy to use. It should be
possible to communicate with old and new applications, with different modules without the
need to worry about the system and network aspects.
(b) Uniform Semantics: In a distributed system, a message-passing system may be used for
the following two types of inter process communication:
i. Local Communication, in which the communicating process are on the same node;

ii. Remote communication, in which the communicating processes are on different

nodes.
Semantics of remote communication should be as close as possible to those of local
communications. This is an important requirement for ensuring that the message passing is easy to
use.

Brightway Computers Page 1

 (c) Efficiency: An IPC protocol of a message-passing system can be made efficient by reducing
the number of message exchanges, as far as practicable, during the communication process.
Some optimizations normally adopted for efficiency include the following:
i. Avoiding the costs of establishing and terminating connections between the same
pair of processes for each and every message exchange between them.
ii. Minimizing the costs of maintaining the connections.
iii. Piggybacking of acknowledgement of previous messages with the next message
during a connection between a sender and a receiver that involves several messages
exchanges.
(d) Correctness: Correctness is a feature related to IPC protocols for group communication.
Issues related to correctness are as follows:
i. Atomicity;
ii. Ordered delivery;

iii. Survivability.
Atomicity ensures that every message sent to a group of receivers will be delivered to either
all of them or none of them. Ordered delivery ensures that messages arrive to all receivers in an
order acceptable to the application. Survivability guarantees that messages will be correctly
delivered despite partial failures of processes, machines, or communication links.

3. Discuss in detail about Synchronization?

A central issue in the communication structure is the synchronization imposed on the
communicating processes by the communication primitives. The semantics used for
synchronization may by broadly classified as blocking and nonblocking types. A primitive is said to
have nonblocking semantics if its invocation does not block the execution of its invoker (the
control returns almost immediately to the invoker); otherwise a primitive is said to be of the
blocking type.
In case of a blocking send primitive after execution of the send statement, the sending
process is blocked until it receives an acknowledgement from the receiver that the message has
been received. On the other hand, for nonblocking send primitive, after execution of the send
statement, the sending process is allowed to proceed with its execution as soon as the message has
been copied to a buffer.
An important issue in a nonblocking receive primitive is how the receiving process knows
that the message has arrived in the message buffer. One of the following two methods is commonly
used for this purpose:
(a) Polling: In this method, a test primitive is provided to allow the receiver to check the
buffer status. The receiver uses this primitive to periodically poll the kernel to check if
the message is already available in the buffer.
(b) Interrupt: In this method, when the message has been filled in the buffer and is ready
for use by the receiver, a software interrupt is used to notify the receiving process.

Brightway Computers Page 2

 semantics
Fig: Synchronous mode of communication with both sends and receives primitives having blocking-type

Send (message); execution

Execution resumed

suspended

execution
Sender’s
Acknowledgment

Message
Executing state
Blocked state

execution suspended
Receive (message);
Execution resumed
Send (Acknowledgment)

execution suspended
Receive (message);

A variant of the nonblocking receive primitive is the conditional receive primitive, which also
returns control to the invoking process almost immediately, either with a message or with an
indicator that no message is available.
When both the send and receive primitives of a communication between two processes use
blocking semantics, the communication is said to be synchronous, otherwise it is asynchronous.
The main drawback of synchronous communication is that it limits concurrency and is subject to
communication deadlocks.

4. Define Buffering and explain it?

In the standard message passing model, messages can be copied many times: from the user
buffer to the kernel buffer (the output buffer of a channel), from the kernel buffer of the sending
computer (process) to the kernel buffer in the receiving computer (the input buffer of a channel),
and finally from the kernel buffer of the receiving computer (process) to a user buffer.
(a) Null buffer (No Buffering): In this case there is no place to temporarily store the
message. Hence one of the following implementation strategies may be used:

Brightway Computers Page 3

 i. The message remains in the sender process’s address space and the execution of
the send is delayed until the receiver executes the corresponding receive.
ii. The message is simply discarded and the time-out mechanism is used to resend
the message after a timeout period. The sender may have to try several times
before succeeding.
The three types of buffering strategies used in inter process communication.
(b) Single-Message Buffer: In single-message buffer strategy, a buffer having a capacity to
store a single message is used on the receiver’s node. This strategy is usually used for
synchronous communication; an application module may have at most one message
outstanding at a time.

Sending Receiving
process process

Mess
age
Single- message
Node buffer
boundary
(b)

Brightway Computers Page 4

Unbounded-Capacity Buffer:
In the asynchronous mode of communication, since a sender does not wait for the receiver
to be ready, there may be several pending message that have not yet been accepted by the receiver.
Therefore, an unbounded-capacity message-buffer that can store all unreceived messages is needed
to support asynchronous communication with the assurance that all the messages sent to the
receiver will be delivered.
(c) Finite-Bound Buffer: Unbounded capacity of a buffer is practically impossible.
Therefore, in practice, systems using asynchronous mode of communication use finite-
bound buffers, also known as multiple-message buffers. In this case message is first
copied from the sending process’s memory into the receiving process’s mailbox and
then copied from the mailbox to the receiver’s memory when the receiver calls for the
message.

Sending Receiving
process Message 1
process

Message 2
Message
Message 3

Message n

Multiple-message
buffer/mailbox/port

(c)

When the buffer has finite bounds, a strategy is also needed for handling the problem of a
possible buffer overflow. The buffer overflow problem can be dealt with in one of the following two
ways:
Unsuccessful communication: In this method, message transfers simply fail, whenever
there is no more buffer space and an error is returned.
Flow-Controlled Communication: The second method is to use flow control, which means
that the sender is blocked until the receiver accepts some messages, thus creating space in the
buffer for new messages. This method introduces a synchronization between the sender and the
receiver and may result in unexpected deadlocks. Moreover, due to the synchronization imposed,
the asynchronous send does not operate in the truly asynchronous mode for all send commands.

5. Explain the client – server architecture model of RPC?

Remote Procedure Call (RPC) is a powerful technique for constructing distributed, client –
server based applications. It is based on extending the conventional local procedure calling, so that
the called procedure need not exist in the same address space as the calling procedure. The two

Brightway Computers Page 5

processes may be on the same system, or they may be on different systems with a network
connecting them.
When making a Remote Procedure Call:
1. The calling environment is suspended, procedure parameters are transferred across the
network to the environment where the procedure is to execute, and the procedure is executed
there.
2. When the procedure finishes and produces its results, its results are transferred back to
the calling environment, where execution resumes as if returning from a regular procedure call.
NOTE: RPC is especially well suited for client-server (e.g. query – response) interaction in
which the flow of control alternates between the caller and callee. Conceptually, the client and
server do not both execute at the same time. Instead, the thread of execution jumps from the caller
to the callee and then back again.
Working of RPC:
Caller Callee
(Client process) (Server process)

Request message
(Cantaions remote
Call procedure and procedure’s parameter Receive request and start
wait for reply procedure execution

Procedure executes

Send reply and wait for

next request
Resume execution Reply message
(Contains result of
procedure execution

Remote procedure call model

Fig: Client – Server Model

The following steps take place during a RPC:

1. A client invokes a client stub procedure, passing parameters in the usual way. The
client stub resides within the client’s own address space.
2. The Client stub marshalls (pack) the parameters into a message. Marshalling includes
converting the representation of the parameters into a standard format and copying each
parameter into the message.
3. The client stub passes the message to the transport layer, which sends it to the remote
server machine.
4. On the server, the transport layer passes the message to a server stub, which demarshalls
(unpack) the parameters and calls the desired server routine using the regular procedure call
mechanism.

Brightway Computers Page 6

 5. When the server procedure completes, it returns to the server stub (e.g., via a normal
procedure call return), which marshalls the return values into a message. The server stub then
hands the message to the transport layer.
6. The transport layer sends the result message back to the client transport layer, which
hands the message back to the client stub.
7. The client stub demarshalls the return parameters and execution returns to the caller.

6. Explain the Implementation Mechanism in RPC?

 RPC mechanism uses the concepts of stubs to achieve the goal of semantic transparency.
 Studs provide a local procedure call abstraction by concealing the underlying RPC
mechanism.
 A separate stub procedure is associated with both the client and server processes.
 RPC communication package known as RPC Runtime is used on both the sides to hide
existence and functionalities of a network.
 Thus implementation of RPC involves the five elements of program.
(1) Client (2) Client Stub, (3) RPC Runtime (4) Server stub (5) Server.
The client, the client stub, and one instance of RPC Runtime execute on the client machine.
The server, the server stub, and one instance of RPC Run time execute on the server machine.
Remote services are accessed by the user by making ordinary LPC.
Client Machine Server Machine

Return Call Call Ser Return

ver

Client stub Server stub

Unpack Pack Unpack Pack

RPC Runtime RPC Runtime

Receive Wai
t Send Receive Send

Client Packs
Server packet

Fig: Implementation of RPC

(1) Client :
i. A Client is a user process which initiates a RPC.
ii. The client makes a normal call that will invoke a corresponding procedure in the
client stub.

(2) Client stub:

Client stub is responsible for the following two tasks:

Brightway Computers Page 7

 i. On receipt of a call request from the client, it packs specifications of the target
procedure and arguments into a message and asks the local RPC Runtime to send it
to the server stub.
ii. On receipt of the result of procedure execution, it unpacks the result and passes it to
the client.

(3) RPC Runtime:

i. Transmission of messages between Client and the server machine across the
network is handled by RPC Runtime.
ii. It performs Retransmission, Acknowledgement, Routing and Encryption.
iii. RPC Runtime on Client machine receives messages containing result of procedure
execution from server and sends it client stub as well as the RPC Runtime on server
machine receives the same message from server stub and passes it to client
machine.
iv. It also receives call request messages from client machine and sends it to server
stub.

(4) Server Stub:

Server stub is similar to client stub and is responsible for the following two tasks:
i. On receipt of a call request message from the local RPC Runtime, it unpacks and
makes a normal call to invoke the required procedure in the server.
ii. On receipt of the result of procedure execution from the server, it unpacks the result
into a message and then asks the local RPC Runtime to send it to the client stub.
(5) Server: When a call request is received from the server stub, the server executes the
required procedure and returns the result to the server stub.

7. Explain the RPC Messages?

Messages we pass from server to client and vice versa need to be in a format such that client
and server can both decode and encode data passed from each other. Popular message formats for
RPC are JSON and XML. Such communication is called JSON-RPC and XML-RPC for RPC that uses
JSON and XML respectively.
(a) JSON-RPC: In JSONO-RPC all messages sent from server or client are valid JSON objects.
Client must send JSON object with following keys:

i. Method: Name of method/service

ii. Params: Array of arguments to be passed
iii. Id: Id is usually integer and makes it easier for client to know which request it
got response to, if RPC calls are done asynchroneously.
Server may reply with JSON objected with following keys:
i. Result: Contains return value of method called. It’s null if error occurred.
ii. Error: If error occurred, this will indicate error code or error message, otherwise
it’s null.

Brightway Computers Page 8

 iii. Id: The id of the request it is responding to.

Brightway Computers Page 9

Example:
Request:
{“method”: “Arith.Multiply”, “params”:[{ A:2, B:3}], “id”: 1}
Response:
{“result”: 6, “error”: null, “id”:1}
JSON-RPC v2 adds support for batch queries and notifications (calls which don’t require response).
(b) XML – RPC: XML – RPC was created by a Microsoft employ in 1998. It evolved and
became SOAP. It’s hard to elaborate it’s specifics in this blog post so I recommend you
checkout XML – RPC Wikipedia article. Basic XML – RPC is as simple as JSON – RPC. Our
above example for JSON – RPC will look like this in XML – RPC:
Request:
<?xml version=”1.0”?>
<methodCall>
<methodName>Airth.Multiply</methodName>
<params>
<param>
<value><int>2</int></value>
</param>
<param>
<value><int>3</int></value>
</param>
</params>
</methodCall>
Response:
<?xml version=”1.0”?>
<MethodResponse>
<params>
<param>
<value><int>6</int></value>
</param>
</params>
</methodResponse>

8. Explain the Cell Semantics in RPC?

In RPC the caller and callee processes can be situated on different nodes. The normal
functioning of an RPC may get
Disrupted due to one or more reasons mentioned below:
(i) Call message is lost or response message is lost.
(ii) The callee node crashes and is restarted.
In RPC system the call semantics determines how often the remote procedure may be
executed under fault conditions. The different types of RPC call semantics are as follows:

Brightway Computers Page 10

 (a) May – Be Call Semantics:
1. This is the weakest semantics in which a timeout mechanism is used that prevents
the caller from waiting indefinitely for a response from the callee.
2. This means that the caller waits until a pre – determined timeout period and then
continues to execute.
3. Hence this semantics does not guarantee the receipt of call message nor the
execution. This semantics is applicable where the response message is less
important and applications that operate within a local network with successful
transmission of messages.
2. Last – Once Call Semantics:
1. This call semantics uses the idea of retransmitting the call message based on
timeouts until the caller receives a response.
2. The call, execution and result of will keep repeating until the result of procedure
execution is received by the caller.
3. The results of the last executed call are used by the caller, hence it known as last –
one semantics.
4. Last one semantics can be easily achieved only when two nodes are involved in the
RPC, but it is tricky to implement it for nested RPCs and cases by orphan calls.
3. Last – of – Many Call Semantics:
1. This semantics neglects orphan calls unlike last – once call semantics. Orphan call is
one whose caller has expired due to node crash.
2. To identify each call, unique call identifiers are used which to neglect orphan calls.
3. When a call is repeated, it is assigned to a new call identifier and each response
message has a corresponding call identifier.
4. A response is accepted only if the call identifier associated with it matches the
identifier of the most recent call else it is ignored.
4. At – Least – Once Call Semantics:
1. This semantics guarantees that the call is executed one or more times but does not
specify which results are returned to the caller.
2. It can be implemented using timeout based retransmission without considering the
orphan calls.
5. Exactly – Once Call Semantics:
1. This is the strongest and the most desirable call semantics. It eliminates the
possibility of a procedure being executed more than once irrespective of the number
of retransmitted call.
2. The implementation of exactly – once call semantics is based on the use of timeouts,
retransmission, call identifiers with the same identifier for repeated calls and a
reply cache associated with the callee.

Brightway Computers Page 11

 9. Explain the Communication Protocols?
Based on the needs of different systems, several communication protocols have been
proposed for use in RPC which are mentioned below:
(i) The Request Protocol:

Client Server

Request message Procedure

First execution
RPC

Request message Procedure

Next execution
RPC

Fig: Request Protocol

1. This protocol is also called as R (request) protocol.

2. It is used in RPC when a called procedure has nothing to return as a result of execution and
the requirement of client confirmation about procedure execution is not needed.
3. As no acknowledgement or reply message is involved, only single message is transmitted
from client to server.
4. The client proceeds after the request message is sent as there is no reply message.
5. This protocol provides May – be call semantics and does not need retransmission of request
message.
6. RPC that uses the R protocol is known as asynchronous RPC which helps to improve the
combined performance of the client and server. This is done because the client does not ait
for a reply and server does not need to send a reply.
7. For an asynchronous RPC, the RPC Runtime does not retry a request in case of
communication failure. TCP is better alternative then UDP since no retransmission is
required and it is connection oriented.
8. Asynchronous RPC with unreliable transport protocol are generally used in implementing
periodic update services. Distributed system window is one of its applications.
(ii) The request/Reply protocol:

Brightway Computers Page 12

 Client Server

Request Message

First Procedure
RPC execution
Reply Message
Acknowledgement for the
request message

Request Message
Acknowledgement for the
Procedure
Next reply of on a previous RPC
execution
RPC Reply Message
Acknowledgement for the
request message

Fig: Request/Reply Protocol

This protocol is also known as RR (request/reply) protocol:

1. It is useful for designing systems which involve simple RPCs.
2. In a simple RPC all the arguments and result fit in a single packet buffer while the call
duration and intervals between calls are short.
3. This protocol is based on the idea of using implicit acknowledgement to eliminate explicit
acknowledgement messages.
4. In this protocol a server reply is considered as an ACK for a clients request and a
subsequent call from a client is considered as ACK of the client’s previous call.
5. Timeout –and – retires technique is used with RR protocol for failure handling.
Retransmission of request message is done when there is no response.
6. RR protocol and timeout technique provides at – least – once call semantics on if duplicate
requests are not filtered out.
7. Exactly once semantics are supported by servers using reply cache which stores replies.
(iii) The Request/Reply/Acknowledgement – Reply Protocol:
Client Server

Request Message

First Procedure
RPC Reply Message execution
Acknowledgement for the
request message

Request Message
Acknowledgement for the
Procedure
Next reply of on a previous RPC
execution
RPC Reply Message
Acknowledgement for the
request message

Fig: request/reply/acknowledge – reply Protocol

Brightway Computers Page 13

 1. This protocol is also known as RRA (request/reply/acknowledge – reply) protocol.
2. RR protocol implements exactly once semantics which requires storage of a lot of
information in the server cache and can lead to loss of replies that have not been delivered.
3. To overcome the limitations or RR protocol, RSA protocol is used.
4. In this clients acknowledge the receipt of reply messages and the server deletes information
from its cache only after it receives an acknowledgement from client.
5. Sometimes the reply acknowledgement message may get lost therefore RRA protocol needs
a unique ordered message identifiers. This keeps a track of the acknowledgement series
sent.

10. Discuss the Client – Server Binding?

Client Stub must know the location of a server before RPC can take place between them.
Process by which client gets associated with server is known as BINDING. Servers export their
operations to register their willingness toprovide services and Clients import operations, asking the
RPC Runtime to locate a server and establish any state that may be needed at each end.
Issues for client – server binding process:
1. How does a client specify a server to which it wants to get bound?
2. How does the binding process locate the specified server?
3. When is it proper to bind a client to a server?
4. Is it possible for a client to change a binding during execution?
5. Can a client be simultaneously bound to multiple servers that provide the same service?

SHORT ANSWER QUESTIONS

1. What is explicit and implicit addressing?

Explicit addressing:
The process with which communication is desired is explicitly named as a parameter in the
communication primitive used.
Implicit addressing:

The process willing to communicate does not explicitly name a process for communication
(the sender names a server instead of a process). This type of process addressing is also known as
functional addressing.

2. What is Group Communication?

The most elementary form of message – based interaction is one – to – one communication
(also known as point – to – point, or unicast communication) in which a single – sender process
sends a message to a single – receiver process. For performance and ease of programming, several
highly parallel distributed applications require that a message – passing system should also provide
group communication facility. Depending on single or multiple senders and receivers.

Brightway Computers Page 14

3. What is all over Multicast?
Atomic Multicast (reliable multicast) has an all – or – nothing property. That is, when a
message is sent to a group by atomic multicast, it is either received by all the surviving (correct)
processes that are members of the group or else it is not received by any of them.

4. What are the components of RPC?

Sun RPC has three components:
(1) rpcgen – a compiler that generates the client and server stub for the definition of a remote
procedure interface. Use – C to generate ANSI C code.
(2) XDR – external Data Representation. Used to encode the data into a portable format.
Simplifies execution among different computer architectures.

(3) A runtime library: -lrpclib.

5. How to send a request and how to get the response?

First, use library function clnt_create (server, DATE_PROG, DATE_VERS, “udp”) to create a
CLIENT handle.
Second, call remote functions in almost the same way as if you are calling local functions.
The request and response will be automatically processed by client stub and server stub.

6. Discuss the issues in IPC by Message Passing?

A message is a block of information formatted by a sending process in such a manner that it
is meaningful to the receiving process. It consists of a fixed – length header and a variable – size
collection of typed data objects. The header usually consists of the following elements:

1. Address: It contains characters that uniquely identify the sending and receiving
processes in the network.

2. Sequence number: This is the message identifier (ID), which is very useful for
identifying lost messages and duplicates messages, in case of system failures.

3. Structural information: This element also has two parts. The type part specifies
whether the data to be passed on to the receiver is included within the message or the
message only contains a pointer to the data, which is stored somewhere outside the
contiguous portion of the message. The second part of this element specifies the length
of the variable – size message data.

Structural
Addresses
information
Actual data Sequence
or pointer to Number of typ number or Receiving Sending
the data bytes/ e message ID process process
elements address address

Variable Fixed – length header

Size collection
of typed data

Fig: A typical message structure

Brightway Computers Page 15

7. Discuss the basic concepts of RPC?
Remote Procedure Call (RPC) is a protocol that one program can use to request a service
from a program located in another computers on a network without having to understand the
network’s details. A procedure call is also sometimes known as a function call or a subroutine call.
IPC part of distributed system can often beconveniently handled by message – passing
model.
1. It doesn’t offer a uniform panacea for all the needs.
2. RPC emerged as a result of this.
3. It can be said as the special case of message – passing model.
A local procedure call and an RPC behave similarly; however, there are semantic differences
due to several properties of RPCs:

(a) Server/client relationship (binding): While a local procedure call depends on a static
relationship between the calling and the called procedure, the RPC paradigm requires a more
dynamic behaviour. As with a local procedure call, the RPC establishes this relationship through
binding between the calling procedure (client) and the called procedure (server). However, in the
RPC case a binding usually depends on a communications link between the client and server RPC
runtime systems. A client establishes a binding over a specific protocol sequence to a specific host
system and endpoint.
(b) No assumption of shared memory: Unlike a local procedure call, which commonly
uses the call – by – reference passing mechanism for input/output parameters, RPCs with
input/output parameters have copy – in, copy – out semantics due to the differing address spaces of
calling and called procedures.
(c) Independent failure: Beyond execution errors that arise from the procedure call itself,
an RPC introduces additional failure cases due to execution on physically separate machines.
Remoteness introduces issues such as remote system crash, communications links, naming and
binding issues, security problems and protocol incompatibilities.
(d) Security: Executing procedure calls across physical machine boundaries has additional
security implications. Client and server must establish a security context based on the underlying
security protocols and they require additional attributes for authorizing access.

8. What are the Transparency issues of RPC?

A transparent RPC is one in which the local and remote procedure calls are
indistinguishable.
Types of transparencies:
(i) Syntactic transparency: A remote procedure call should have exactly the same syntax
as local procedure call.
(ii) Semantic transparency: The semantics of a remote procedure call are identical to
those of alocal procedure call.
Syntactic transparency is not an issue but semantic transparency is difficult.
Difference between remote procedure calls and local procedure calls:
1. Unlike local procedure calls, with remote procedure calls.

Brightway Computers Page 16

 (a) Disjoint Address Space
(b) Absence of shared memory
(c) Meaningless making call by reference, using addresses inarguments and pointers.
2. RPC’s are more vulnerable to failure because of:
(a) Possibility of processor crashes or
(b) Communication problems of a network.

9. Discuss the stub generation?

Automatically stub generation: Interface Definition Language (IDL) is used here, to define
the interface between a client and the server.
Interface definition:
1. It is a list of procedure names supported by the interface together with the types of their
arguments and results.
2. It also plays role in reducing data storage and controlling amount of data transferred
over the network.
3. It has information about type definitions, enumerated types and defined constants.

Export the interface:

A server program that implements procedure in the interface.

Import the interface:

1. A client program that calls procedures from an interface.
2. The interface definition is compiled by the IDL compiler.
3. IDL compiler generates components that can be combined with client and server
programs, without making any changes to the existing compilers;
4. Client stub and server stub procedures;
5. The appropriate marshaling and unmarshaling operations;

6. A header file that supports the data types.

10. Discuss the server management?

Servers can be implemented in two ways:
(a) Stateful servers, (b) Stateless servers.
(a) Stateful servers: A Stateful Server maintains client’s state information from one RPC to
the next.
(i) They provide an easier programming paradigm.
(ii) They are more efficient than stateless servers.
(b) Stateless Server: Every request from a client must be accompanied with all necessary
parameters to successfully carry out the desired operation.
(i) Stateless servers have distinct advantage over Stateful server in the event of a
failure.
(ii) The choice of using a stateless or a stateful server is purely application dependent.

Brightway Computers Page 17