Electrical computers and digital processing systems: memory – Storage accessing and control – Memory configuring
Reexamination Certificate
2000-03-10
2003-02-25
Courtenay, III, St. John (Department: 2151)
Electrical computers and digital processing systems: memory
Storage accessing and control
Memory configuring
C709S241000
Reexamination Certificate
active
06526494
ABSTRACT:
BACKGROUND OF THE INVENTION
1. Field of the Invention
The present invention relates to computer systems. More specifically, the present invention relates to communication between processes in a computer system.
2. Background Information
Inter-Process communication is a fundamental part of modern day computer system design. Inter-process communication is typically facilitated via a calling scheme in a kernel of the computer system which manages communication between a client and server process. One of the problems associated with such inter-process communication is that typically, when a client task invokes a server task, the client task allocates a certain amount of memory to pass arguments (parameters) to the server task, and that memory is typically used until any arguments are returned from the server. That is, even though control and processing has been passed to the server application, memory is still consumed in the client application until return arguments are returned from the server. Thus, a buffer is allocated which is not used for a large portion of the time in which the server task has been passed control by the client. This especially is an issue in multi-threaded environments wherein a plurality of buffers are allocated, one for each thread. Multiple buffers remain allocated and, for the most part, stay unused for the duration of each thread, unnecessarily consuming memory resources.
A typical prior art scheme for inter-process communication is illustrated with reference to FIG.
1
. Typically, a client task (e.g.,
110
of
FIG. 1
) allocates a certain amount of memory space, such as
111
, which is typically a buffer or other protected memory space available to the client and kernel processes, and marshals arguments into the buffer area. For the purposes of the remainder of this application “marshaling” refers to the process wherein a client process packages arguments. parameters or other data in a memory area to be passed to the server process. For security reasons, this memory area is typically available only to the client process
110
and the kernel of the operating system
100
.
Upon a call to the server process
120
shown in
FIG. 1
, the kernel detects the call and control is passed to the kernel
100
. In this instance, the client typically passes a pointer or a reference to the memory area
111
, and the kernel can then access any arguments passed in the buffer
111
. Kernel
100
then receives the reference to memory area
111
, and copies the arguments contained within memory area
111
into a temporary memory area in kernel
100
. A second memory area
101
accessible by the kernel and the server routine
120
may then be used to communicate from kernel
100
to the server
120
. The arguments in the temporary buffer are copied into memory area
121
. Then, the server routine thread for process
120
is created, and a reference is made to it by kernel
100
. The server
120
accepts a reference to memory area
121
from kernel
100
, and the server unmarshals the arguments.
While server process
120
is active, after the invocation by kernel
100
, buffer
111
is still allocated in client
110
. In certain prior art applications, buffers for marshaling arguments are on the order of five kilobytes in length. The client maintains this memory area open and accessible for the duration of server
120
's execution. Upon completion of execution of server
120
, a reverse of the client/server calling process described above is performed wherein the server uses its own buffer
121
for marshaling arguments into and a reference is passed to the area to kernel
100
. Eventually, return arguments are within the original buffer area
111
contained within client
110
. It is only at this time, in typical prior art systems, that the buffers
111
and
121
in both the client and the server are deallocated. Thus, the buffers are allocated and are idle for a long time in which kernel
100
and server process
120
are active and perhaps idle (e.g., awaiting I/O servicing). This is an unnecessary consumption of memory resources. Moreover, in multi-threaded environments, client
110
and server
120
may allocate numerous buffers such as
111
and
121
, and maintain these in an allocated state while waiting for control to be returned by their corresponding called processes. This results in a very large and unnecessary consumption of memory resources.
As the number of threads in a computer system increases, the amount of memory consumed by such communication becomes quite significant. Thus, the prior art suffers from several shortcomings.
SUMMARY
A computer-implemented method and apparatus in a computer system for inter-process communication. A first procedure allocates a first buffer in a first memory space shared by the first procedure (e.g. a client process) and a second procedure (e.g. a kernel or server process). The first procedure then marshals arguments for communicating with the second procedure in the first buffer. The first procedure indicates that a message for the second procedure is being passed and passes a first reference to the first buffer in the first memory space to the second procedure. The second procedure detects the indication of the message by the first procedure. The second procedure then references the first buffer and copies the arguments contained in the first buffer into a temporary buffer. The second procedure can then deallocate the first buffer. In implemented embodiments of the present invention, inter-process communication is more efficient because the first buffer is deallocated upon receipt of the communication by the second procedure.
The second procedure can then process the arguments contained in the temporary buffer. Upon completion of processing the arguments, the second procedure then allocates a second buffer in the first memory space for marshaling return arguments. The second procedure returns and passes a second reference to the second buffer to the first procedure. The first procedure detects the return to the first procedure and unmarshals the arguments in the second buffer. The first procedure deallocates the second buffer and continues execution. In implemented embodiments of the present invention, the first memory space is preallocated to a first size prior to the calling of the second procedure by the first procedure wherein the first memory space references a first number of buffers. Each of the first number of buffers may be allocated by the first or the second procedure by indicating that buffers are in use by the first or the second procedure. Indication of each of the first number of buffers being in use by the first procedure or the second procedure is performed via an atomic swap between an allocation flag and a value indicating that a buffer is in use, wherein the allocation flag is used for indicating whether one of the first number of buffers is in use.
Other features and advantages of the present invention will be apparent from the description and figures which follow below
REFERENCES:
patent: 5218699 (1993-06-01), Brandle et al.
patent: 5307490 (1994-04-01), Davidson et al.
patent: 5321841 (1994-06-01), East et al.
patent: 5430876 (1995-07-01), Schreiber et al.
patent: 5434995 (1995-07-01), Oberlin et al.
patent: 5446901 (1995-08-01), Owicki et al.
patent: 5491800 (1996-02-01), Goldsmith et al.
patent: 5497463 (1996-03-01), Stein et al.
patent: 5511197 (1996-04-01), Hill et al.
Tucker, Allen, B., “Programming Languages”, second edition, McGraw-Hill, pp. 486-489, 1986.*
Nelson, B. J., “Remote Procedure Call”, Ph.D. thesis, Carnegie-Mellon University, p. 115, 1981.*
Druschel, P. et al., “FBUFS: A High-Bandwidth Cross-Domain Transfer Facility”, Operating Systems Review (SIGOPS), Dec. 1, 1993, pp. 189-202, XP00605643.
“Simulating Shared Buffer Communication In A Distributed Processing Environment”, IBM Technical Disclosure Bulletin, vol. 34, No. 11, Apr. 1, 1992, pp. 340-350, XP00303288.
Krieger, O. et al., “The ALLOC Stream Facility, A Redesign of Application-Level Stream I/O”, Computer vol. 27,
Hamilton Graham
Kougiiouris Panagiotis
Blakely & Sokoloff, Taylor & Zafman
Courtenay III St. John
Sun Microsystems Inc.
LandOfFree
Method and apparatus for space-efficient inter-process... does not yet have a rating. At this time, there are no reviews or comments for this patent.
If you have personal experience with Method and apparatus for space-efficient inter-process..., we encourage you to share that experience with our LandOfFree.com community. Your opinion is very important and Method and apparatus for space-efficient inter-process... will most certainly appreciate the feedback.
Profile ID: LFUS-PAI-O-3171759