JPH05334266A - Processor for server/client model - Google Patents

Abstract

PURPOSE:To attain a data sharing between a server and a client which fulfills a fault resistance and speed up of a processing, in the processor of a server/ client model in the system of a multiprocessor constitution. CONSTITUTION:To a request from a client 12, a cell to be assigned to the cilent 12 is secured in a nonvolatile shared memory 17 by a cell assignment processing means 14 of a server 11, and an identifier in the system is set in the area. A cell access processing means 16 of a kernel 13 allows only the valid client 12 to which the cell is assigned to perform an access to the cell, based on the identifier set in the cell. An communication information setting processing means 15 of the client 12 sets communication information to the server 1 through the cell access processing means 16 provided at the kernel 13 at the cell in the shared memory 17.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a server / client model processor which enables efficient data sharing with fault tolerance between a server and a client.

In a server / client model system, a client requests a server that provides a specific processing function for processing by message communication or the like. It is necessary to reduce the overhead of the message communication as much as possible and to ensure the consistency of resources such as data related to the processing request even when there is a failure.

[0003]

2. Description of the Related Art In a system based on a server / client model having a multiprocessor configuration, various kinds of information are transmitted by message communication, and information is shared between a client space and a server space. As a system based on such a server / client model, there is one described in the following documents, for example.

Reference: Nikkei Electronics 199
1.2.18, no. 520, Muramatsu et al., “Developing an OS that can be maintained and operated without stopping the system.” In the past, when sharing information between a server and a client in such a system, whether information is delivered by message communication, Alternatively, information is shared by sharing a file provided in an external storage device or the like.

As a process requiring sharing of information between the server and the client, the server keeps the processing state of the client in response to a process error on the client side,
Processes that need to guarantee the consistency of resources such as data,
Examples include transaction processing.

[0006]

In a server / client model system, when information is shared between a server and a client, message communication and file sharing are used. However, fault tolerance or high processing speed is used. There was a problem that one of them was blocked. The problem will be specifically described below.

When it is necessary to share information on the client side on the server side by message communication, message communication to the server side is required every time the information on the client side changes. On the other hand, in message communication between the client and server, it is necessary to synchronize because information must be transmitted correctly. Therefore, if the information on the client side changes frequently,
Since a large amount of message communication is performed, the overhead of message communication becomes large, which hinders speeding up of processing.

Therefore, as a method of reducing message communication and sharing information between the server and the client, it is conceivable to share and use the memory area on the main memory. This method shares information by allowing the same memory area to be accessed by the server and the client. However, in this method, the range that can be shared is limited to one processor module that can share the same main memory, and information cannot be shared when the server and the client are in different processor modules. Further, when a failure occurs in the processor module, the contents of the main memory are also lost, so that there is a problem that the fault tolerance cannot be realized.

Considering the fault tolerance, the memory on the main memory is not sufficient because it is volatile. Therefore, it is conceivable to use the file for information sharing as a non-volatile one in which information is not lost even if a failure occurs. By using files, the server and client can be placed in different processor modules as long as the same file can be referenced. Further, even if the processor module in which the client is present goes down, the server can access the file, so that the processing can be continued without loss of information. The file access here is not limited to a specific processor module, and it is premised that a plurality of processor modules can equally access the file.

However, in the method of sharing information between the server and the client using such a file, although the fault tolerance can be realized, it is necessary to access the file every time the information on the client side changes, and the message communication is performed. In addition, there is a problem that the overhead becomes large.

It is an object of the present invention to solve the above problems and to provide a data sharing system which satisfies both requirements of fault tolerance and high speed processing.

[0012]

FIG. 1 is a diagram for explaining the principle of the present invention. In FIG. 1, 10-1 to 10-n are processor modules each having one or more CPUs and a local memory, 11 is a server that provides a specific processing function, and 12-1 and 12-2 are servers 11. A client, which is a process requesting processing, 13 is a kernel of an operating system distributed and arranged in each processor module, 14 is a cell allocation processing means,
15-1 and 15-2 are notification information setting processing means, 16-1
1 to 16-n are cell access processing means, 17 is a non-volatile shared memory (SSU) accessible from each processor module, and 18 is a server acquisition area.

Cell allocation processing means 14 is provided in the server 11.
To provide. The cell allocation processing means 14 is the client 12
In response to a request from -1, ..., an area (hereinafter referred to as a cell) to be allocated to the client 12-1, ... Is secured from the server acquisition area 18 acquired in advance in the shared memory 17, and is unique in the system. It is a processing means for setting an identifier in the area.

Further, cell access processing means 16-1, ... Are provided in the kernel 13. Cell access processing means 1
Based on the identifier set in the cell of the server acquisition area 18, 6-1 provides an access function that permits access to the cell only to the legitimate clients 12-1, ... To which the cell is assigned. It is a processing means.

Notification information setting processing means 15-1, ... Are provided in the clients 12-1 ,. The notification information setting processing means 15-1, ... Is processing means for setting the notification information to the server 11 in the cell in the shared memory 17 via the cell access processing means 16-1, provided by the kernel 13. ..

[0016]

2 is an explanatory view of the operation of the present invention. According to the present invention, the non-volatile shared memory 17, which has been used only for the fault tolerance of the server 11 in the past, is applied to the information sharing between the server and the client, thereby achieving both high speed processing and fault tolerance. It will meet new needs.

From each client 12-1, ... To the server 1
When transmitting some information that frequently changes to 1, the client 12-1, ... Requests the server 11 for an area in the shared memory 17.

The server 11 acquires the server acquisition area 18 in the shared memory 17 in advance, and divides it into the cells (CELL1 to CELLk) for management. One cell is reserved for a request from the client 12-1, ... And a unique identifier is set in the system in the cell.

Thereafter, the clients 12-1, ...
As shown in, information can be written in the cell in the server acquisition area 18 via the cell access processing means 16. That is, as shown in FIG. 2, the image is shared between the server 11 and each client 12.

From client 12-1, ... To server 11
Since information needs to be written in the allocated cells only, the overhead is small even when the information changes frequently. Further, since the shared memory 17 is non-volatile, information is not lost even when the client 12-1 or the like crashes. Furthermore, since the access permission to the server acquisition area 18 is checked by the identifier set in the cell, the security between the clients 12 is also guaranteed.

That is, the server acquisition area 18 is the server 1
Only 1 and kernel 13 can access it. Since the client 12 can access only via the kernel 13, security can be guaranteed. Kernel 1
No. 3 cannot be tampered with because it checks based on the kernel information held by the client 12 that the client 12 cannot change.

The server 11 has a server acquisition area 18
Can be directly accessed without going through the cell access processing means 16.

[0023]

FIG. 3 is an explanatory view of an embodiment of the present invention. Hereinafter, an embodiment of the present invention will be described with reference to an example of the server 11 that manages a transaction state. A large processing flow is as shown in (a) to (f) of FIG.

(A) Initialization of server space (b) Declaration of start of use of transaction function by client 12 (c) Allocation of shared memory (SSU) cell by server 11 (d) Start of transaction by client 12 and change of state (e) Crash of client 12 or end of transaction function (f) Guarantee of consistency by server 11 and release of SSU cell Hereinafter, the entire processing flow will be described in detail. (a) Initialization of server space The server 11 acquires a server acquisition area 18 of a predetermined size in the shared memory 17 at the time of initialization. This area is divided into cells, a free space management bitmap 32 is created, and all the cells are set to the free space.

A mailbox 30 for receiving a message such as a processing request is created. By registering the destination of the mailbox 30, the destination of the mailbox 30 is made public so that a message can be received from any space.

Wait for receipt of a message regarding a processing request. (b) Declaration of start of use of transaction function by client 12 Invoke use start declaration mechanism of transaction function provided by the server 11. Normally, the message interface between the client 12 and the server 11 is hidden in the function provided by the server 11 in order to improve serviceability.

Acquire a destination in the server space. Sends a message to the server space. Then, it waits for a reply message from the server space.

When the client 12 receives the reply message from the server 11,
Request the initialization of the SSU cell and create the access environment. It returns from the use start declaration mechanism of the transaction function provided by the server 11. (c) Shared memory (SSU) cell allocation by the server 11 When the server 11 receives a processing request message, the server 11 analyzes the content of the message. If the transaction function usage declaration is made, the following processing is performed.

With the free space management bitmap 32,
Search for free SSU cells. When an empty SSU cell is found, the corresponding bit in the empty management bitmap 32 is set to be in use, and the position of that bit is set as the cell number.

Information such as the allocated SSU cell is registered as a capability. As a result, the capability can be issued to the client 12. This information is managed as object information 31.

S for the client 12
The cell number and capabilities of the SU cell are reported in a reply message. After that, the client 12 can use this capability to communicate with the server 11. When the server 11 receives the message sent by using the capability, the server 11 can retrieve the corresponding capability information. If the client space crashes, the kernel 13
By the service of the crash detection mechanism of, the destination of the capability issued to the crashed space is notified to that effect. (d) Start transaction and change state by client 12 Call the transaction start mechanism.

Information indicating that a transaction is started is recorded in the shared memory 17 using the access mechanism of the kernel 13. Access to resources for transaction execution. (e) Crash of client 12 or termination of transaction function Calls the transaction termination mechanism.

The prepare start state is recorded in the shared memory 17. Change the resource to the prepare state. The commit start state is recorded in the shared memory 17.

Change the resource to the commit state. The transaction end state is recorded in the shared memory 17. A message to the effect that it will be returned using the capability is sent to the server 11. If the client space crashes after the above process (b), the kernel 13 automatically performs this process.
Since these processes are the same as those in the conventional technique, further detailed description will be omitted. (f) Guarantee of consistency by the server 11 and release of SSU cell The server 11 receives the return message addressed to the capability.

The SSU cell number is extracted by referring to the capability information of the object information 31. When it is detected that the transaction is not in the end state by referring to the information in the SSU cell, the REDO / UNDO process of the resource state for guaranteeing the consistency is performed. That is, a process of completing the process for the resource or a process of returning to the state before the process is performed so that the data does not become halfway.

The capability information issued to the client 12 is deleted. After that, the corresponding capability becomes invalid and cannot be used. Release the SSU cell.

By the above processing, the information on the transaction status can be shared between the client 12 and the server 11, and even if the client 12 crashes, the consistency of resources can be guaranteed.

FIG. 4 is a flow chart of cell allocation processing by the server 11 in the above processing. Server 11
Performs the following processing when allocating cells. (1) After completing the initialization of the server space, wait for the received message related to the processing request.

(2) When a message is received, it is determined whether the message is valid. The validity of a message is determined by, for example, whether or not the data (password) set in a specific field in the message match. Client 1 in advance in that particular field
If the secret word negotiated between the server 2 and the server 11 is not set, the request is an unreasonable request and is processed as an error.

(3) If the message is valid, a free cell in the server acquisition area 18 is searched by the free space management bitmap 32 shown in FIG. (4) If there is no empty SSU cell, return an error message.

(5) If there is an empty SSU cell, a request identifier (ID) is generated. This ID may be any ID that can be uniquely identified by the system, and for example, the process ID of the request source client can be used as the request ID.

(6) The request ID is embedded in the SSU cell. (7) Generate the capability for this cell and register the object information 31.

(8) A message notifying the capability, SSU cell number, request ID, etc. is returned to the request source, and the process ends. FIG. 5 shows the client 1 in the above process.
6 is a flowchart of a cell acquisition process according to 2.

(1) It is determined whether the SSU cell has been acquired. If it has been acquired, the process ends. (2) If the SSU cell has not been acquired, the destination of the message to the server 11 is acquired.

(3) A message requesting acquisition of an SSU cell is sent to the server 11. (4) to (5) The kernel 13 is requested to initialize the SSU cell and an access environment to the SSU cell is created.

FIG. 6 is a flow chart of the cell access process by the kernel 13. Particularly, FIG. 6A shows the process for the SSU cell initialization request from the client 12.

(1) The ID of the requesting client is compared with the ID embedded in the SSU cell by the server 11. (2) If there is no matching ID, it is an error and the process is terminated.

(3) Initialization such as clearing the inside of the cell area is performed. (4) The access range of the SSU, that is, the cell position information in the SSU is stored in the work area on the memory as the access range.

FIG. 6B shows the processing of the kernel in response to the write request from the client 12 to the SSU cell. (1) The access range of the client 12 stored in the work area at the time of initialization is taken out.

(2) If the access range is not registered, the process ends. (3) If there is an access range, update the relevant part. FIG. 7 shows the kernel 13 crash detection mechanism.
6 is a processing flowchart of consistency guarantee and cell release performed by the server 11 when the client 12 is notified of a crash.

(1)-(2) If a crash notification message is received while waiting for a received message,
The registered object information 31 shown in FIG. 3 is taken out.

(3) Based on the SSU cell number, the corresponding S
The SU cell is accessed to check whether or not the transaction end state information is written in the SSU cell. If it is in the transaction end status, move to processing (7).

(4) to (6) Depending on whether or not the REDO process is necessary, the R
Performs EDO processing or UNDO processing. That is, either the processing for the resource such as data is completed or the processing is performed before the processing.

(7) The object information 31 is deleted. (8) Release the SSU cell to make it an empty cell. Through the above processing, the server 11 ensures the data consistency even when the client 12 crashes.

[0055]

As described above, according to the present invention,
By using a non-volatile shared memory to share information between the server and client, it is possible to realize a system with high speed and fault tolerance.

[Brief description of drawings]

FIG. 1 is a diagram illustrating the principle of the present invention.

FIG. 2 is an explanatory view of the operation of the present invention.

FIG. 3 is an explanatory view of an embodiment of the present invention.

FIG. 4 is a flowchart of cell allocation processing by the server according to the embodiment of the present invention.

FIG. 5 is a flowchart of a cell acquisition process by a client according to an embodiment of the present invention.

FIG. 6 is a cell access processing flowchart of the kernel according to the embodiment of the present invention.

FIG. 7 is a flowchart of consistency guarantee and cell release processing by the server according to the embodiment of the present invention.

[Explanation of symbols]

 10-1, 10-2, ... Processor module 11 Server 12-1, 12-2, ... Client 13 Kernel 14 Cell allocation processing means 15-1, 15-2, ... Notification information setting processing means 16-1, 16- 2, ... Cell access processing means 17 Shared memory 18 Server acquisition area

Claims (1)

[Claims] 1. A processor module comprising a plurality of processor modules (10) and a non-volatile shared memory (17) accessible from each processor module (10).
A server-client model in which a kernel (13) that controls the system on (0), a server (11) that provides a specific processing function, and a client (12) that requests processing to that server (11) operate In the processing device, the server (11)
Is a cell allocation process that secures an area to be allocated to the client (12) in the shared memory (17) in response to a request from the client (12) and sets a unique identifier in the system within the area. Means (14), the kernel
The cell access processing means (13) permits access to the area only to the legitimate client (12) to which the area is allocated based on the identifier set in the area in the shared memory (17). 16), and the client (12)
Is a cell access processing means provided by the kernel (13).
Notification information setting processing means (1) for setting notification information to the server (11) in an area in the shared memory (17) via the (16)
A server / client model processor characterized by comprising 5).