Browse Prior Art Database

Cached Shared Memory for Distributed Subsystems

IP.com Disclosure Number: IPCOM000112882D
Original Publication Date: 1994-Jun-01
Included in the Prior Art Database: 2005-Mar-27

Publishing Venue

IBM

Related People

McNeill, AB: AUTHOR [+2]

Abstract

Disclosed is a method for implementing a move mode architecture in an environment in which shared memory does not exist between two processors. Shared memory is simulated by caching the move mode delivery pipes. The pipes are brought into and out of local memory by means of bus master transfers, with the adapter processing the pipes in local memory.

This text was extracted from an ASCII text file.
This is the abbreviated version, containing approximately 13% of the total text.

Cached Shared Memory for Distributed Subsystems

      Disclosed is a method for implementing a move mode architecture
in an environment in which shared memory does not exist between two
processors.  Shared memory is simulated by caching the move mode
delivery pipes.  The pipes are brought into and out of local memory
by means of bus master transfers, with the adapter processing the
pipes in local memory.

      A Subsystem Control Block (SCB) move mode architecture
specifies a method of interaction between two processes using shared
memory.  Information is received and sent by means of a shared
control area and a pair of shared memory queues (delivery pipes)
containing information.  This method is efficient if the shared
memory is local to both the receiving process and the sending
process.  However, in many cases, while one processor is local to the
shared memory, the other processor accesses memory through a bus
interface.  The overhead required to transfer information and control
data results in a reduction in the performance of the non-local
processor.

      The move mode architecture specifies a method for interaction
between two processors through the use of two circular queues, called
"pipes," and two control areas called surrogate areas.  While pipes
can conceivably be shared by two software threads on a single
processor, normally pipes are shared between any two bus masters,
that is, between any two processors, which can transfer data to and
from a shared memory space.

      From a system perspective, there is an inbound pipe for
information coming to the system and an outbound pipe for information
being sent from the system.  There is an inbound surrogate area and
an outbound surrogate area, with each surrogate area containing a
Start of Element (SOE) pointer maintained by the processor receiving
the packets of data, and a Start of Free (SOF) pointer maintained by
the processor sending packets of data.

      Fig. 1 shows an example of the enqueue surrogate area, which
contains two words of information--the offset to Start of Free and
the surrogate enqueue status field.

      Fig. 2 shows an example of the dequeue surrogate area, which
contains two words of information--the offset to Start of Free and
the surrogate dequeue status field.

      Fig. 3 shows an example of an unwrapped pipe.  While the
Surrogate Start of Free (SSOF) pointer is updated by an enqueue
algorithm, the Surrogate Start of Elements (SSOE) pointer is updated
by a dequeue algorithm.  The information, represented by slash marks
(/), is located between the Start of Elements and the SSOF.  The
dequeue algorithm takes commands off the pipe, with the SSOE being
updated following the removal of each command.  Elements are taken
off in this way until the SSOF is reached.  Similarly, the enqueue
algorithm places commands onto the queue, beginning at the SOF and
continuing until the SSOE is reached.

      Fig. 4 shows an...