JP2001331457A - Distributed shared memory system - Google Patents

Abstract

PROBLEM TO BE SOLVED: To improve flexibility in the case of operating a remote memory. SOLUTION: In order for a remote machine 100 to share a shared memory 114 inside a host machine 110 as the remote memory, the remote machine 100 is provided with a remote memory control application 101 for operating the shared memory 114 as the remote memory and an object-oriented communication framework 103 and also the host machine 110 is provided with a host memory control application 111 for operating the scared memory 114 as a host memory and an object-oriented communication framework 113. Then, a function group 102 for the remote memory control application 101 to access the object-oriented communication framework 103 is realized by a remote type definition.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a distributed sharing in a loosely-coupled computer system in which a plurality of computers each having an independent address space are connected via a network to share data distributed on a memory in each computer. It relates to a memory system.

[0002]

2. Description of the Related Art A conventional example of this kind is disclosed in, for example,
As described in Japanese Patent Application Laid-Open No. 0-91445 and Japanese Patent Application Laid-Open No. 7-152708, the shared memory in the loosely-coupled computer system is physically distributed, so that each computer accesses data stored in the remote memory. It is common to create special functions to manipulate remote memory.

[0003]

However, in the above conventional example, since a special function is created and accessed by manipulating the remote memory, the data types such as data types and structures of the programming language are stored in the remote memory. Cannot be declared and accessed, and there is a problem that flexibility is low.

[0004] In view of the above problems, an object of the present invention is to provide a distributed shared memory system which can increase flexibility when operating a remote memory.

[0005]

According to a first aspect of the present invention, in order to achieve the above object, a plurality of computers having independent address spaces are connected via a network to distribute data distributed on a memory in each computer. A distributed shared memory system in a shared loosely-coupled computer system, wherein the computer includes interface means for accessing a remote memory in another computer by a remote memory description class of an object-oriented programming language. I do.

The second means is characterized in that in the first means, the interface means has means for accessing a remote memory by data type designation.

The third means is characterized in that in the first and second means, the interface means has means for accessing a remote memory by designating a structure type.

The fourth means is characterized in that in the first to third means, the object-oriented programming language is a C ++ language.

[0009]

Embodiments of the present invention will be described below with reference to the drawings. FIG. 1 is a block diagram showing an embodiment of a distributed shared memory system according to the present invention. FIG. 2 is a diagram showing a remote memory class of the object-oriented communication framework of the remote machine of FIG. 1 and an object-oriented communication framework of the host machine. FIG. 3 is an explanatory diagram showing the relationship between remote type definition classes, FIG. 4 is an explanatory diagram showing a sample program for operating a remote memory, and FIG. 5 is an operation sequence based on the sample program in FIG. FIG. 6 is an explanatory diagram showing the relationship between structures, and FIG. 7 is an explanatory diagram showing an operation sequence of the structure by a contractor.

FIG. 1 shows a remote machine 100 and a host machine 11 as a plurality of computers having independent address spaces.
0 shows a loosely-coupled computer system which is connected via a network 120 and shares data distributed on a memory in each computer (only the shared memory 114 in the host machine 110 is shown in FIG. 1).

In such a configuration, the remote machine 100 shares the shared memory 114 in the host machine 110 as a remote memory.
00 has a remote memory control application 101 operating the shared memory 114 as a remote memory and an object-oriented communication framework 103, and the host machine 110 has a host memory control application 111 operating the shared memory 114 as a host memory.
And an object-oriented communication framework 113. Then, the remote memory control application 10
1 realizes a function group 102 for accessing the object-oriented communication framework 103 by remote type definition.

Here, the data type designation in the programming language generally includes a data type of a reserved word provided by the programming language and a data type newly created by a program developer. The data type generation, deletion, operation, and assignment processing are designed on the assumption that data exists in the same address space. Therefore, in order to specify a data type for an independent address space, data generation, deletion, operation, and assignment processing must be realized using a special function. In the present invention, the object-oriented communication frameworks 103, 11
3 is used to implement the shared memory 114. In addition, the data type designation of the remote memory accessing the shared memory 114 and the method of generating the data type (pointer and array) are realized as those equivalent to the functions provided in the programming language.

Object-oriented communication framework 10
3 is a remote memory class (rmemor
y) 200, and this remote memory class 200 implements creation, deletion, calculation, and assignment processing for the remote memory. At this time, in order to generate a remote memory, a request for the size of memory reservation is made using a unique handle number. The remote memory class 200 corresponds to the object-oriented communication framework 11 of the host machine 110.
It communicates with the shared memory class (hmemory) 250 of 3 and issues a memory reservation request to the shared memory 114 on the host machine 110.

The host memory object of the host machine 110 receives a request for memory allocation from the shared memory 114.
, The requested memory size is secured from the area, and the start address of the secured memory area is sent to the remote memory class 200 as a reply message. The remote memory class 200 receives the reply message and
4 is obtained, and the handle number and the obtained start address are registered as a pair in the dictionary class.

Further, the remote type definition is realized by using the function of the remote memory class 200. The remote memory type is specified by using a template function supported by the C ++ language. The template function is a function for defining an arrangement and an operator for an unspecified set. FIG. 3 shows a class relation diagram of the remote type definition class. FIG.
The class association diagram shown in UML (Unified Modeling Lang)
uage) notation. Remote type definition class (3
20, 330, 340, and 350) are classes for operating the remote memory class 200, and operate as encapsulation classes for hiding the operation procedure from the remote memory class. Hereinafter, the remote type definition class will be described in detail.

(1) rtype_base 310: a base class of remote type definition classes (320, 330, 340, 350).
Manage output. When an object of the base class (rtype_base) 310 is generated (when a constructor is executed), a unique handle number 311 is assigned to the object. Handle number 3 for remote memory 114
11 to request the memory area of the remote memory 114. The handle number 311 is stored in the remote memory 11
4 is used as a number to operate.

(2) rtype <T> 320: reserved word data type (d
ouble, int, char ..) is realized. Realize remote access by using operator overload function.

(3) rstruct <T> 330: implements a remote type definition template class for a structure. rstruct <T> 3
30 is an rtype_base class 310 and a template type <T>
331 are implemented as multiple inheritance classes. The remote structure type definition template class (rstruct <T>) 330
This class manages the structure created using the remote type definition class for the template argument type. As a management function, the class defined by the remote structure class has a function to secure a remote memory in a space where all elements of the structure are continuous.

An instance of a structure has the same function as a remote type definition class.

It has a function of copying instances of the same structure.

Nested structure (hierarchical structure)
Also, the functions described above are realized.

FIG. 4 shows a sample program of the remote type definition in the present invention. This sample program is an example of a sample program that generates a remote memory from the object-oriented communication framework 103 of the remote machine 100 and performs an operation.
Substitute 10 and 20 for 1, n2 respectively, and set the remote variable su
By substituting the result of addition to m = n1 + n2, 10
+ 20 = 30.

The operation sequence of the sample program shown in FIG. 4 will be described with reference to FIG.

Operation 501: A unique handle number is assigned when an instance (n1: rint) of the remote type definition class is generated. Communication with the remote memory class (rmemory) 200 is performed using this handle number.

Operation 502: n1: rint outputs a message requesting the memory allocation size = 4 bytes (int type size) to the remote memory class (rmemory) 200 when the constructor is executed. Remote memory class (rm
emory) 200 converts the message format so that the request message for memory reservation can be transmitted to the shared memory class (hmemory) 250 of the host machine 110 and transmits the message. There is a delay between the remote memory class (rmemory) 200 and the shared memory class (hmemory) 250 due to communication via the network 120. Communication with the remote memory class (rmemory) 200 is performed using the handle number of the instance (n1: rint).

Operation 503: Shared memory class (hmemory)
In 250, the remote memory class (rmemory) 200
, A 4-byte memory is secured in the shared memory area managed by the shared memory class (hmemory) 250, and the secured start address is returned as a message to the remote memory class (rmemory) 200.

Operation 504: Remote memory class (rmem
ory) 200 receives a message indicating that the memory allocation succeeded, and handles the instance (n1: rint) handle number and the start address of the memory allocation attached to the reply message from the shared memory class (hmemory) 250 as a dictionary. Store in class (z11). In the future, when accessing this remote memory reservation space, an instruction is given by the handle number, the remote memory class (rmemory) 200 converts the handle number into an address, and the shared memory class (hmemo).
ry) Give instructions to 250. The remote memory class (rmemory) 200 supports synchronous / asynchronous processing for a memory operation message from the instance (n1: rint). Therefore, the instance (n1: rin
By issuing a signal to the thread accessing t), synchronous / asynchronous is realized by stopping / restarting the thread.

Operation 505: When an assignment operation of an immediate value 10 (similarly for a local variable) is performed on the instance (n1: rint), an overloaded assignment operator is used.
The message of write (handle, value) is converted and transmitted to the remote memory class (rmemory) 200. handle is the handle number of n1: rint (here ""
1), an object having an assignment value of "10" is set in robject_base, which is a container object storing the assignment value and the size of the object to be assigned (4 bytes in this case).

Operation 506: Remote memory class (rmem
ory) 200 receives write (handle, value) and
Search the dictionary class for the memory address value corresponding to the handle number of the argument. Here, the instance (n1: rin
Address (n1_addr) corresponding to handle number "1" in t)
And a shared memory class (hmemory) 250
Sends a write (n1_adr, 10) message to

Operation 507: Shared memory class (hmemory)
250 receives the write (n1_adr, 10) message and returns to n1
Write a value of 10 to 4 bytes from the address space of _adr. After writing is completed, the remote memory class (rmemor
y) Send a write completion reply message to 200.

Operation 508: Remote memory class (rmem
ory) 200, after receiving the write completion message,
If synchronous processing is in progress, a signal is issued.

Operation 509: The value of n1: rint and the value of n2: rint are added by the overload function of the addition (+) operator, and the result of addition is assigned to sum: rint.

Operation 510: The sum: rint object adds the values of the remote memories to each other, but the entities of the remote memories n1: rint and n2: rint are the remote machine 1
Since it does not exist on the remote memory class 00, a remote memory acquisition message is transmitted to the remote memory class (rmemory) 200 using the handle number.

Operation 511: Shared memory class (hmemory)
Upon receiving the remote memory value request message, the 250 acquires the value of the corresponding shared memory area, and transmits a reply message to the remote memory class (rmemory) 200.

Operation 512: remote memory class (rmem
ory) 200 receives the reply message of the remote variable value request message, acquires the value of the remote variable, issues a signal to sum: rint, and returns from the standby state.

Operation 513: If the sum: rint object is n
After obtaining the remote variable values of 1: rint and n2: rint, the process of adding the remote variables is performed, and a message for writing the addition result to the remote memory area indicated by the handle number of sum: rint is transmitted.

Operation 514: Destructor n1; is shown, but it actually means a case where it goes out of the scope. When moving out of the scope, the n1: rint destructor starts, and attaches the handle of n1: rint to the remote memory class (rmemory) 200 so that the memory area requested by n1: rint is released to rmemory. Send a message.

Operation 515: Remote memory class (rmem
(ory) 200, upon receiving the memory release request message, searches the memory pointer corresponding to n1.handle, and transmits the memory release request message to the shared memory class (hmemory) 250.

Operation 516: In the halloc, when the memory release request message is received, the corresponding memory area is released. After the release processing is completed, the remote memory class (rmem
ory) Returns a completion message to 200.

Next, the structure will be described with reference to FIG. rstruct <T> defines remote variables using rtype <T> for each member variable of the structure as shown in the sample code below, and then defines the defined structure with rstuct <T> to define the remote variable. It can be defined as a structure.

Struct Man {rtype <int>id; rtype <int>age;}; rstruct <Man>rMan; In the structure (Man), the handle number of the member defined by the remote type definition rtype <int> is All rhs: hobject62
Registered in one container class. rhs: hobject621
The registration to the URL uses the object generation order in the multiple inheritance of the C ++ language, and is stored in rhs: hobject during the generation process of the object constructor. An advantage of handle number management by this method is that it can cope with a case of a multiple structure in which structures are nested. rhs: hobject 621 means an instance rhs of the dictionary class hobject for registering a handle number.

Next, features of the C ++ language constructor will be described. Derived classes can call base class constructors but cannot inherit them. Constructors, like most C ++ functions, can have default arguments and can use a member initialization list. Constructors cannot be called in the same way as regular functions. Regarding the calling order of the constructor of a class having multiple base classes, the base class constructor is called before the constructor of the derived class. Base class constructors are called in the order they are declared. rstruc
The class declaration of t <T> is described as follows.

Template <class T> class rstruct: public rtype_base, public T {public: rstruct ();:}; In this case, the calling sequence of the constructor is rtype_base base class constructor, T type base class constructor, rstruct <T> Called in the order of the base class constructor.

FIG. 7 shows the order of execution of constructors when an object of rstruct <Man> is generated. With reference to FIG. 7, a procedure for storing all elements in rstruct <T> in rhs: hobject will be described. As an example, the remote member variable of Man is allocated in a continuous memory space on the test server, and the handle number of the remote member variable is rs
The procedure managed by turct <T> :: rhs will be described.

Operation 701: The constructor of the base class rType_base of rMan is activated first with respect to the execution order of constructors when an instance of "rMan man;" is generated. Use the overload function of the constructor and rs
Execute the constructor rtype_base (eGroup) for truct <T>. eGroup is an enumeration type of groups, and indicates that the handle number of the constructor of rtype_base (size) to be executed is registered in groups. Instructs ralloc to request contiguous remote memory space.

Operation 702: The remote memory allocation request message alloc (handle, size) from the constructor rtype_base (size) to be executed is a message serial (handle, mode) instructing a continuous memory space.
Send The first argument of serial () is the handle number of rstruct <T> itself, and the second argument mode sets "start" which specifies the continuous start mode. The handle number is described in srial () in order to support nesting of structures and nesting of arrays. To cancel memory continuation, use "en" as the second argument.
d "is described and executed (710).

Operation 703: Message push_goup (hand) for instructing groups to retain the handle number of the constructor rtype_base (size) to be executed.
le). The reason why the handle number of rstruct <T> is used as an argument is to cope with the nesting of structures and arrays as in the above-described operation 702. To accommodate nested structures, groups are implemented in a stack format.

Operation 704: When the constructor processing of rtype_base (eGroup) is completed, the constructor of the next base class is executed. Since rstruct <T> defines the type T as a base class, the constructor of the type T, that is, Man, is executed. However, since Man does not specify a constructor, a default constructor generated by the compiler is executed.

Operation 705: The constructor of the remote member variable id: rint of Man is activated, and outputs a remote memory reservation request message to ralloc.

Operation 706: If the container of group is not empty, store the handle number of id: rint.

Operation 707: The constructor of age: rint, which is a remote member variable of Man, is activated, and outputs a remote memory reservation request message to ralloc.

Operation 708: If the container of group is not empty, store the handle number of age: rint.

Operation 709: Finally, the constructor of man: rMan itself is executed. In this constructor, to obtain the handle number of the remote type declaration class executed by the base class, obtain the container class of the handle number executed by the base class constructor from groups.

Operation 710: The ralloc is notified that the continuous space indication of the remote memory reservation request message is released.

Operation 711: A remote memory reservation request message is sent to halloc when a continuous memory reservation release message is received and the nesting of the memory reservation release command is eliminated. In this case, the message is serial (1, s
The memory allocation request messages from (tart) to serial (1, end) are grouped and transmitted.

[0056]

As described above, according to the first aspect of the present invention, the remote memory is provided with the interface means for accessing the remote memory using the remote memory description class of the object-oriented programming language. Flexibility can be increased.

According to the second aspect of the present invention, since the remote memory is accessed by specifying the data type, realization of the remote type definition makes it possible to specify the same type as the local memory type. For example, to specify the data type of the C / C ++ language, a reserved data type (int, long, char, floa
t, double ...), so that the same function as the data type specification of the C / C ++ language can be realized as a class library even in the remote memory type specification.

According to the third aspect of the present invention, since the remote memory is accessed by specifying the structure type, the same type specification as the local structure type specification is possible by realizing the remote type definition of the structure. Becomes

According to the fourth aspect of the present invention, since the object-oriented programming language is the C ++ language, flexibility can be enhanced when operating a remote memory.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an embodiment of a distributed shared memory system according to the present invention.

FIG. 2 is an explanatory diagram showing a remote memory class of an object-oriented communication framework of the remote machine of FIG. 1 and a shared memory class of an object-oriented communication framework of a host machine.

FIG. 3 is an explanatory diagram showing the relationship between remote type definition classes.

FIG. 4 is an explanatory diagram showing a sample program for operating a remote memory.

FIG. 5 is an explanatory diagram showing an operation sequence according to the sample program of FIG. 4;

FIG. 6 is an explanatory diagram showing the relationship between structures.

FIG. 7 is an explanatory diagram showing an operation sequence by a contractor of the structure.

[Explanation of symbols]

 REFERENCE SIGNS LIST 100 remote machine 110 host machine 101 remote memory control application 103, 113 object-oriented communication framework 111 host memory control application 114 shared memory 120 network 200 remote memory class 250 shared memory class

──────────────────────────────────────────────────続 き Continued on the front page (51) Int.Cl. ⁷ Identification symbol FI Theme coat ゛ (Reference) G06F 15/167 G06F 15/167 B

Claims (4)

[Claims] 1. A distributed shared memory system in a loosely-coupled computer system in which a plurality of computers having independent address spaces are connected via a network to share data distributed on a memory in each computer, The present invention provides a distributed shared memory system comprising interface means for accessing a remote memory in another computer using a remote memory description class of an object-oriented programming language. 2. The distributed shared memory system according to claim 1, wherein said interface means has means for accessing a remote memory by specifying a data type. 3. The distributed shared memory system according to claim 1, wherein said interface means includes means for accessing a remote memory by designating a structure type. 4. The distributed shared memory system according to claim 1, wherein the object-oriented programming language is a C ++ language.