JPH04358258A - Server/client type numerical calculating system - Google Patents

Abstract

PURPOSE:To eliminate necessity for calling a numerical calculation library or considering data structure such as an intermediate result, etc., for numerical calculation on an application program for numerical calculation and further to execute the numerical calculation at high speed with a high-speed processor as a server. CONSTITUTION:An application processing mechanism 11 of a client 10 is constituted to mainly manage only the process of the numerical calculation and to transmit a calculation request containing the data ID of calculating object data through a communication interface mechanism 12 to a server 20 when the calculation is required. When this calculation request is received, a numerical calculation processing mechanism 21 of the server 20 calls the correspondent numerical calculation library, executes the requested calculation with data in an initial data area 23a or an intermediate result area 23b shown by the data ID as the object while using a parameter peculiar for the function type of the requested calculation in a parameter data base 30 and returns the result data ID to the application processing mechanism 11.

Description

[Detailed description of the invention]

0001

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a server-client numerical calculation method suitable for executing numerical calculation application programs.

0002

[Prior Art] Conventionally, a numerical calculation application program (numerical calculation program) is configured as shown in Figure 9, and in addition to the application code, it has a numerical calculation library code that is called from the application code. Ta. That is, conventional application programs were created by calling a numerical calculation library.

The application program having the configuration shown in FIG. 9 has generally been executed as follows. That is, first, initial data is read. Then, calculations are performed by calling the numerical calculation library several times, and the final result is output. When calling this numerical calculation library, numerical calculation parameters used in numerical calculation using the library are passed as arguments.

In numerical calculations performed by calling a numerical calculation library, intermediate calculation results (intermediate results) are held in an intermediate result data area (intermediate result area) prepared in the application program. therefore,
As shown in Figure 9, in the case of an application program that obtains the final result after n numerical calculation steps, n-1
It is necessary to manage various types of intermediate results on the application program.

[0005]

[Problem to be Solved by the Invention] As mentioned above, FIG.
In the conventional numerical calculation method using an application program as shown in , it was necessary for the application program (the process that executes it) to call the numerical calculation library itself.

However, there is a problem in that the method of calling a numerical calculation library is generally complicated and requires time and effort for an application programmer to learn. Furthermore, since the method of calling the numerical calculation library differs depending on the vendor providing the numerical calculation library, there is also a problem that the independence and portability of the application are deteriorated.

[0007] Furthermore, when calling a numerical calculation library, the numerical calculation parameters used in the numerical calculation using the library must be passed as arguments, and furthermore, the numerical calculation parameters used in the numerical calculation using the library must be passed as arguments. Since the results must be managed on the application, the program becomes complicated, and this also places a burden on the application programmer. Furthermore, there is a problem in that the execution performance of numerical calculations is determined by the performance of the processing unit (CPU) on which the application program runs.

The present invention was made in view of the above circumstances, and its purpose is to eliminate the need to consider calling a numerical calculation library on an application program for numerical calculations, and to display intermediate results of numerical calculations, etc. The object of the present invention is to provide a numerical calculation method that can be managed using identifiers, thereby simplifying application programs.

Another object of the present invention is to provide a processing unit (CPU) on which an application program for numerical calculation runs.
The object of the present invention is to provide a numerical calculation method that can perform numerical calculations at high speed even if the processing performance is low.

0010

[Means and effects for solving the problems] This invention has the following features:
In order to reduce the load on the application program for numerical calculations (to simplify the structure), the code necessary to perform numerical calculations (numerical calculation library) is added to the process of executing the application (first processing). mechanism)
This is characterized by a configuration in which calculation processing can proceed simply by separating it from the application process and consolidating it into a server process (second processing mechanism) and issuing a calculation request from the application process to the server process.

[0011] Furthermore, the present invention has a structure in which intermediate results of numerical calculations are retained and managed in a server process in association with their data identifiers, and the data identifiers are passed to the application process in place of the intermediate results. By doing so, in the application process,
It is only necessary to hold and manage the data identifier passed from the server process, and there is no need to pay attention to data structures such as intermediate results.

[0012] Furthermore, this invention focuses on the fact that parameters necessary for numerical calculations are often fixed for each calculation type, and it is possible to store such fixed parameters (standard parameters, default values) for each calculation type. A parameter database (parameter storage means) is provided, and the server process uses the parameters corresponding to the requested numerical calculation type stored in the parameter database if no special parameters are specified by the application process. This configuration eliminates the need to pass parameters from the application process to the server process. Therefore, the application process only needs to specify parameters when it wants to set parameters other than default values.

[0013] Furthermore, by adopting a configuration in which numerical calculation requests and data identifiers are exchanged between the application process and the server process through a communication interface mechanism, high-speed computers (for example, supercomputers) interconnected through a network can ) by running a server process on the server and accessing the process.
A high-speed numerical calculator can be used efficiently from a low-speed calculator.

[0014]

DESCRIPTION OF THE PREFERRED EMBODIMENTS FIG. 1 is a block diagram showing an embodiment of a numerical calculation system to which the present invention is applied.

In FIG. 1, 10 is a processing device running an application program for numerical calculation, and 20 is a processing device that receives a numerical calculation request from the processing device 10, calls a numerical calculation library, and performs numerical calculation processing. Therefore, the processing device 10 is called the client 10, and the processing device 2
0 will be called a server (numerical calculation server) 20.

The client 10 mainly includes the above application program and a CP that executes the program.
An application processing mechanism 11 implemented by U is provided. In this embodiment, the application program running on the client 10 does not include (the code for) a numerical calculation library as shown in FIG. 9 and a data area for various intermediate results (intermediate result area). The client 10 is also provided with a communication interface mechanism 12 for exchanging data and the like with the server 20 side.

On the other hand, the server 20 has a numerical calculation processing mechanism 21 realized mainly by the above-mentioned numerical calculation library (code) and a CPU that executes the library (code), and the client 10 side. A communication interface mechanism 22 is provided for exchanging such information.

The server 20 also stores initial data that can be subjected to numerical calculations with an identifier (
an initial data area 23a for holding intermediate results (intermediate results) of numerical calculations in correspondence with their data IDs; The final result is the data I
Each data area of the final result area 23c to be held in correspondence with D is secured.

As described above, in the server 20, data areas such as (the code of) the numerical calculation library and each intermediate result area, which were conventionally placed in the application program, are placed separately from the application.

A default parameter database (hereinafter referred to as a parameter database) 30 is connected to the server 20, in which default values (default parameters, standard parameters) of various parameters necessary when performing numerical calculations are stored for each type of calculation. . The client 10 and the server 20 are interconnected by a communication line 40 via communication interface mechanisms 12 and 22.

Next, the operation of the configuration shown in FIG. 1 will be explained using 5 variables x 10
The flowchart in Figure 2 and the flowchart in Figure 3 are taken as an example of calculating the covariance matrix of the data and finding its eigenvalue vector.
This will be explained with reference to the sequence chart as appropriate. In addition,
FIG. 2 is a flowchart showing the processing procedure on the client 10 side for performing the above calculation, and FIG. 3 is a sequence chart showing the communication procedure between the client 10 and the server 20 when performing the above calculation.

First, the application processing mechanism 11 on the client 10 side requests logon from the server 20 side via the communication interface mechanism 12 (step S1). As a result, the communication interface mechanism 22 of the server 20
) passes an identifier (session ID) indicating a session, which is a logical communication path between the client 10 and the server 20, to the client 10 side. Thereby, communication between the client 10 and the server 20 is subsequently performed via the session of this ID.

When the application processing mechanism 11 acquires the session ID passed from the server 20 side (step S2), it reads one record of data that can be the subject of numerical calculation from a file (not shown) (step S3), and stores the data in the data area. Setup (data setting) is performed as follows (step S4).

First, during the communication between the client 10 (the application processing mechanism 11 therein) and the server 20 (the numerical calculation processing mechanism 21 therein), data (input data to the server 20, output data from the server 20) Data) is passed through a certain data structure. An outline of this data structure is shown in FIG.

The data structure shown in FIG.
It has information on data size (1 data size) that specifies the number of bytes per data, and data dimension that specifies the dimension on the data array. In this example, the data dimension is "1" for vectors and "1" for matrices.
2". Further, the data structure in FIG. 4 has a pointer to a list of data amounts for the number of dimensions and a pointer to a data entity.

Therefore, for example (3.1, 4.6, 2
．． Assuming that there is a data set 9, 1.3, 6.0), and each data is a 4-byte real number type, step S
The data area set up in step 4 is as shown in FIG. Note that "TYPE FLOAT" in the figure indicates that the data type is a real number type.

When the application processing mechanism 11 finishes step S4, it performs a procedure to send the data set in step S4 to the server 20 via the communication interface mechanism 12 (step S5). In this procedure, data having the structure shown in FIG. 4 and a data sending control block are sent to the server 20.

When data is sent from the application processing mechanism 11, the server 20 receives the sent data (
data structure) is held in the initial data area 23a in association with a data ID for identifying the same data, and the data ID is sent to the client 10 via the communication interface mechanism 22. The application processing mechanism 11 in the client 10 acquires the data ID sent from the server 20 and internally holds it (step S6).

The structure of the data sending control block described above consists of a sending mode field and a data ID field, as shown in FIG. Here, the sending mode is a flag indicating whether it is new sending or addition to already sent data, and only in the adding mode, the data ID to be added is specified in the data ID field (in the new sending mode, the data Specify the ID (obtained from the server 20 when the ID was sent to the server 20). On the other hand, on the server 20 side, in the case of the addition mode, if there is data with the specified ID, the data is added and managed as a set of data.

[0030] Once the data ID has been attached, the data is
As will be described later, all can be accessed from the client 10 (the application processing mechanism 11 therein) only through this ID. As a result, the application processing mechanism 11
is freed from the hassle of maintaining and managing data structures.

When the application processing mechanism 11 repeats steps S3 to S6 described above until it detects the end of the file (EOF), it repeats several numerical calculation requests as described below. Here, first, a request to calculate a covariance matrix is issued from the application processing mechanism 11 to the server 20 via the communication interface mechanism 12 (step S
7).

In this embodiment, a numerical calculation request from the application processing mechanism 11 to the server 20 is realized by a call interface having the structure shown in FIG. In the figure, “
Data ID”, “Calculation Type
e'' is a data type defined on the programming language, and represents a data ID and a calculation function type (here, a flag indicating a covariance matrix), respectively.

[0033] The numerical calculation processing mechanism 21 in the server 20
When a numerical calculation request (covariance matrix calculation request) using the call interface with the structure shown in FIG. ) and calls the numerical calculation library that fits the initial data area 23a.
The requested calculation (covariance matrix calculation) is performed on the data with the specified data ID within.

[0034]The numerical calculation processing mechanism 21 is connected to the server 2.
A calculation result area (here, the intermediate result area 23b) is secured in the process space of 0 (the server process) to store the calculation results, a new data ID is assigned to this result area (intermediate result area 23b), and the The ID is returned to the application processing mechanism 11 of the client 10 via the communication interface mechanism 22.

The application processing mechanism 11 internally holds the data ID (here, the data ID of the calculation result of the covariance matrix) sent from the numerical calculation processing mechanism 21 (step S8). The application processing mechanism 11 can start the next task simply by holding this data ID. If information about the data entity (covariance matrix calculation result) is required, it can be accessed through the data ID as described later.

Now, the numerical calculation processing mechanism 2 in the server 20
1 reads the parameter database 30 when the server 20 is started up, and holds default values (default parameters) of various parameters necessary for executing numerical calculations. The parameters on this server 20 side are:
As described below, it can be replaced as necessary from the application processing mechanism 11 during program execution.

The above-mentioned parameters include parameters characteristic of numerical calculation execution, such as a convergence determination constant for eigenvalue calculation and the maximum number of iterations. In numerical calculations using conventional application programs, these parameters must be specified each time the numerical calculation library is called, but in this embodiment, they are stored in the server 20, so if the parameters need to be changed (replaced) Just set it. Here, the application processing mechanism 11 of the client 10 specifies replacement of the convergence determination constant for eigenvalue calculation to the server 20 (step S9), and the corresponding parameter already held in the numerical calculation processing mechanism 21 is replaced with the specified parameter. It is assumed that

When the application processing mechanism 11 specifies replacement of the convergence determination constant for eigenvalue calculation (this designation is unnecessary if replacement is not required), the application processing mechanism 11 executes the process shown in FIG. Numerical calculation processing mechanism 2 in the server 20 using the structure call interface
A request is made to calculate the eigenvalue vector for 1 (step S10). Here, the data ID of the calculation result (intermediate result data) obtained from the server 20 in response to the covariance matrix calculation request in step S7 is specified as "Data ID", and the data ID of the calculation representing the eigenvalue vector is specified as "Calculation Type". Function type is specified.

The numerical calculation processing mechanism 21 in the server 20 is
When a request for calculating an eigenvalue vector is received from the application processing mechanism 11 in the client 10, a numerical calculation library matching the request is called, and the intermediate result area 2 is
An eigenvalue vector is calculated for the data with the designated data ID in 3b using internally held parameters (convergence determination constants for eigenvalue calculation, etc.).

[0040]The numerical calculation processing mechanism 21 is connected to the server 2.
A calculation result area (here, the final result area 23c) is secured in the process space of 0 (the server process) to store the calculation result of the eigenvalue vector, and a new data ID is assigned to this result area (final result area 23c). Then, the ID is returned to the application processing mechanism 11 of the client 10 via the communication interface mechanism 22. The application processing mechanism 11 internally holds the data ID (of the calculation result of the eigenvalue vector) sent from the numerical calculation processing mechanism 21 (step S11).

In this embodiment, the calculation result required by the application processing mechanism 11 is only the eigenvalue vector. Therefore, the application processing mechanism 11 specifies the data ID of the eigenvalue vector obtained in step S11, and sends a data sending request to the server 20 via the communication interface mechanism 12 (step S12).

Now, the application processing mechanism 11 can access the data entity on the server 20 only through the data ID, as described above. Therefore, in this embodiment, this type of access (data sending request) is
This is implemented using a call interface having the structure shown in FIG.

In FIG. 8, "Attribute" is a flag indicating the required data attribute. This “Att.
If you specify a flag representing the data entity as "ribute", the data of the data ID specified by "DataID" (here, the data of the calculation result of the eigenvalue vector stored in the final result area 23c of the server 20) will be transferred to the server. 20 to the client 10 and stored in a data area with the structure shown in FIG.
It is also possible to specify that additional information such as the functional type of the calculation for which the data was generated is to be obtained as an "Attribute".

In this way, the application processing mechanism 11
acquires the data of the calculation result of the eigenvalue vector (stored in the final result area 23c) from the server 20 in response to a data sending request of the eigenvalue vector using the calling interface having the structure shown in FIG. 8 (step S13). As a result, the application processing mechanism 11 outputs the acquired data (step S14), and then requests the server 20 to log off via the communication interface mechanism 12 (step S15).

[0045] In the above embodiment, the case where only the client (processing device) 10 and the server (processing device) 20 are connected through a communication line has been described, but the invention is not limited to this. For example, if a high-speed processing device such as a supercomputer exists in a network system in which a large number of processing devices are interconnected via a network, by logging on from a low-speed processing device (client) using the same processing device as a server,
It is also possible to utilize the high-speed numerical calculation function of a high-speed processing device.

Furthermore, each processing device on the network does not need to be fixedly set as either a client or a server, and can be configured to operate as either a client or a server.

[0047]

[Effects of the Invention] As detailed above, according to the present invention,
The code necessary to perform numerical calculations (numerical calculation library) is transferred to the process that executes the application (the first
It is separated from the server process (second processing mechanism) and placed on the server process (second processing mechanism), and the application process manages only the steps for numerical calculation, and the application process only issues calculation requests to the server process. Since the configuration allows the calculation process to proceed, there is no need to write a function call interface for executing various and complicated numerical calculations on the application program. This allows application programmers to write programs for complex numerical calculations using only a few simple calling interfaces.

Further, according to the present invention, the intermediate results of numerical calculations are retained and managed in the server process in correspondence with their data identifiers, and the data identifiers are sent to the application process in place of the intermediate results. Since we configured it to pass, in the application process,
It is only necessary to hold and manage the data identifier passed from the server process, and there is no need to pay attention to the data structure of intermediate results, etc. This also simplifies the application program and reduces the burden on the application programmer. can.

Further, according to the present invention, a parameter database (
The server process uses the parameters corresponding to the numerical calculation type in the parameter database unless a special parameter is specified by the application process.Usually, parameters are transferred from the application process to the server process. It is no longer necessary to pass , and from this point of view as well, the application program can be simplified.

Furthermore, according to the present invention, since the application process and the server process do not need to run on the same machine, the server process can be run and accessed on high-speed computers interconnected by a network. This allows efficient use of high-speed numerical calculators from low-speed computers.

[Brief explanation of the drawing]

FIG. 1 is a block diagram showing an embodiment of a numerical calculation system to which the present invention is applied.

FIG. 2 is a flowchart showing the processing procedure on the client 10 side when calculating a covariance matrix and finding its eigenvalue vector in the same embodiment.

FIG. 3 is a sequence chart showing a communication procedure between the client 10 and the server 20 when calculating a covariance matrix and finding its eigenvalue vector.

FIG. 4 is a diagram showing a data structure applied in the same embodiment.

FIG. 5 is a diagram showing a specific example of the data structure of FIG. 4;

FIG. 6 is a diagram showing the structure of a data sending control block.

FIG. 7 is a diagram showing a description example of a call interface for requesting numerical calculation.

FIG. 8 is a diagram showing a description example of a call interface for a data sending request.

FIG. 9 is a diagram showing the configuration of a conventional application program for numerical calculation.

[Explanation of symbols]

10... Client (processing device), 11... Application processing mechanism (first processing mechanism), 12... Communication interface mechanism, 20... Server (processing device), 21... Numerical calculation processing mechanism (second processing mechanism), 22 ...Communication interface mechanism, 23a...Initial data area, 23b...Intermediate result area, 23c...Final result area, 30...Parameter database, 40...Communication line.

Claims (3)

[Claims] Claim 1: A first processing mechanism that executes an application program for numerical calculation, which, when numerical calculation is required, sends a numerical calculation request having a data identifier for identifying target data. and a first processing mechanism that issues a data sending request with a data identifier for identifying the same data when data such as calculation results is required, and the above-mentioned numerical value from this first processing mechanism. When a calculation request is received, the requested numerical calculation process is performed on the data indicated by the above data identifier in the request, and the calculation result is associated with a data identifier for identifying the calculation result. At the same time, this data identifier is returned to the first processing mechanism in place of the calculation result, and when a data sending request is received from the first processing mechanism, the data in the request is a second processing mechanism that returns internally held data indicated by the identifier to the first processing mechanism; and a second processing mechanism that sends and receives the numerical calculation request and the data identifier between the first processing mechanism and the second processing mechanism. a communication interface mechanism for performing communication including communication, wherein the first processing mechanism is a client and the second processing mechanism is a client.
A server-client numerical calculation method characterized in that the processing mechanism functions as a server and performs numerical calculations. 2. The first processing mechanism sends initial data that can be subjected to numerical calculation to the second processing mechanism in advance, and the second processing mechanism processes the data sent from the first processing mechanism. Claim 1, wherein the data identifier is internally held in correspondence with a data identifier for identifying the same data, and the data identifier is notified to the first processing mechanism.
Server/client type numerical calculation method described. 3. Further comprising parameter storage means for storing various standard parameters necessary for numerical calculations for each type of calculation, wherein the second processing mechanism does not specify any special parameters by the first processing mechanism. 3. The server-client numerical calculation method according to claim 2, wherein standard parameters corresponding to the requested numerical calculation type stored in said parameter storage means are used.